@solidxai/core 0.1.12 → 0.1.13-beta.10

package/src/services/media.service.ts

@@ -1,13 +1,14 @@
-import { forwardRef, Inject, Injectable, Logger, NotFoundException } from '@nestjs/common';
+import { BadRequestException, forwardRef, Inject, Injectable, Logger, NotFoundException } from '@nestjs/common';
 import { ModuleRef } from "@nestjs/core";
 import { InjectEntityManager } from '@nestjs/typeorm';
-import { EntityManager, In } from 'typeorm';
+import { EntityManager, In, Not } from 'typeorm';
 import * as path from 'path';
 import { Readable } from 'stream';
 
 import { ConfigService } from '@nestjs/config';
 import { CRUDService } from 'src/services/crud.service';
 import { DiskFileService, S3FileService } from 'src/services/file';
+import { classify } from 'src/helpers/string.helper';
 import { MediaDownloadUrlService } from 'src/services/media-download-url.service';
 
 
@@ -16,11 +17,12 @@ import { BasicFilterDto } from 'src/dtos/basic-filters.dto';
 import { MediaStorageProviderType } from 'src/dtos/create-media-storage-provider-metadata.dto';
 import { Media } from 'src/entities/media.entity';
 import { MediaStorageProviderMetadata } from 'src/entities/media-storage-provider-metadata.entity';
+import { MediaFieldCrudManager, SolidMediaType } from 'src/helpers/field-crud-managers/MediaFieldCrudManager';
 import { FieldMetadataRepository } from 'src/repository/field-metadata.repository';
 import { MediaStorageProviderMetadataRepository } from 'src/repository/media-storage-provider-metadata.repository';
 import { MediaRepository } from 'src/repository/media.repository';
 import { ModelMetadataRepository } from 'src/repository/model-metadata.repository';
-import { buildDiskMediaPath, buildStoredMediaFileName, getEffectiveS3Region, resolveMediaIsPublic, } from 'src/services/media-storage.utils';
+import { buildDiskMediaPath, getEffectiveS3Region, resolveMediaIsPublic, } from 'src/services/media-storage.utils';
 import { getMediaStorageProvider } from "./mediaStorageProviders";
 
 @Injectable()
@@ -103,40 +105,25 @@ export class MediaService extends CRUDService<Media> {
       throw new NotFoundException('Media storage provider metadata not found');
     }
 
-    const savedMedias = [];
-    for (let i = 0; i < files.length; i++) {
-      const file = files[i];
-      const storageProvider = createDto.mediaStorageProviderMetadata as MediaStorageProviderMetadata;
-      const fileName = buildStoredMediaFileName(file);
+    createDto['fieldMetadata'].mediaStorageProvider = createDto['mediaStorageProviderMetadata'];
 
-      switch (storageProvider.type) {
-        case MediaStorageProviderType.Filesystem:
-          const fileStoragePath = buildDiskMediaPath(fileName, this.settingService, storageProvider);
-          await this.diskFileService.copy(file.path, fileStoragePath);
-          createDto['relativeUri'] = fileName;
-          break;
-        case MediaStorageProviderType.AwsS3:
-          const bucketName = storageProvider.bucketName;
-          const region = getEffectiveS3Region(this.configService, storageProvider.region);
-
-          // Read file from disk and upload to S3
-          const fileData = await this.diskFileService.read(file.path);
-          await this.s3FileService.write(`${bucketName}:${fileName}`, fileData, { contentType: file.mimetype, region });
+    const validator = new MediaFieldCrudManager({
+      type: createDto['fieldMetadata']?.type as SolidMediaType,
+      required: true,
+      fieldName: 'files',
+      mediaMaxSizeKb: createDto['fieldMetadata']?.mediaMaxSizeKb,
+      mediaTypes: createDto['fieldMetadata']?.mediaTypes || [],
+      isUpdate: false,
+    });
+    const validationErrors = validator.validate(createDto, files);
+    if (validationErrors.length > 0) {
+      throw new BadRequestException(validationErrors.map(error => error.error).join(', '));
+    }
 
-          createDto['relativeUri'] = fileName;
-          break;
-        default:
-          break;
-      }
-      // Delete temp file from disk
-      await this.diskFileService.delete(file.path);
+    const storageProviderType = createDto['mediaStorageProviderMetadata'].type as MediaStorageProviderType;
+    const storageProvider = await getMediaStorageProvider(this.moduleRef, storageProviderType);
 
-      delete createDto['isPublic'];
-      const media = this.repo.create(createDto as Partial<Media>) as Media;
-      const savedMedia = await this.repo.save(media);
-      savedMedias.push(savedMedia)
-    }
-    return savedMedias
+    return storageProvider.store(files, { id: Number(createDto['entityId']) }, createDto['fieldMetadata']);
   }
 
   async remove(id: number) {
@@ -190,9 +177,13 @@ export class MediaService extends CRUDService<Media> {
   async delete(id: number, solidRequestContext: any = {}) {
     const media = await this.repo.findOne({
       where: { id },
-      relations: ['mediaStorageProviderMetadata'],
+      relations: ['mediaStorageProviderMetadata', 'modelMetadata'],
     });
 
+    if (media) {
+      await this.assertMediaDeletable([media]);
+    }
+
     const result = await super.delete(id, solidRequestContext);
 
     if (media) {
@@ -207,9 +198,11 @@ export class MediaService extends CRUDService<Media> {
       where: {
         id: In(ids),
       },
-      relations: ['mediaStorageProviderMetadata'],
+      relations: ['mediaStorageProviderMetadata', 'modelMetadata'],
     });
 
+    await this.assertMediaDeletable(mediaRecords);
+
     const result = await super.deleteMany(ids, solidRequestContext);
 
     for (const media of mediaRecords) {
@@ -219,6 +212,33 @@ export class MediaService extends CRUDService<Media> {
     return result;
   }
 
+  /**
+   * Media belonging to a published draft/publish-enabled record must survive edits made to
+   * later drafts (see DraftPublishHelperService.cloneMediaForVersion) - deleting it directly
+   * would strip the published version's media out from under it. Mirrors the equivalent
+   * entity-level guard in DraftPublishHelperService.assertDraftPublishDeleteAllowed.
+   */
+  private async assertMediaDeletable(mediaRecords: Media[]): Promise<void> {
+    const blockedIds: number[] = [];
+
+    for (const media of mediaRecords) {
+      if (!media.modelMetadata?.draftPublishWorkflow) continue;
+
+      const entityRepository = this.entityManager.getRepository(classify(media.modelMetadata.singularName));
+      const owningEntity = await entityRepository.findOne({ where: { id: media.entityId } as any });
+
+      if (owningEntity && (owningEntity as any).isPublished === true) {
+        blockedIds.push(media.id);
+      }
+    }
+
+    if (blockedIds.length > 0) {
+      throw new BadRequestException(
+        'Media belonging to a published record cannot be deleted. Edit the record to create a draft first'
+      );
+    }
+  }
+
   private async decorateMediaRecords(medias: Media[]): Promise<void> {
     for (const media of medias) {
       await this.decorateMediaRecord(media);
@@ -258,6 +278,17 @@ export class MediaService extends CRUDService<Media> {
     }
 
     try {
+      // Draft/publish versioning may clone a Media row that reuses the same
+      // relativeUri (see DraftPublishHelperService.cloneMediaForVersion) instead of
+      // duplicating the underlying file. Skip the physical delete if another row
+      // still references it.
+      const stillReferenced = await this.repo.exists({
+        where: { relativeUri: media.relativeUri, id: Not(media.id) },
+      });
+      if (stillReferenced) {
+        return;
+      }
+
       const mediaStorageProvider = await this.resolveMediaStorageProvider(media);
       if (!mediaStorageProvider) {
         return;

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

@@ -0,0 +1,39 @@
+import { BadRequestException, Injectable } from "@nestjs/common";
+import { isNotEmpty, matches } from "class-validator";
+import { ModelMetadataService } from "./model-metadata.service";
+
+@Injectable()
+export class MetadataValidationService {
+  constructor(
+    private readonly modelMetadataService: ModelMetadataService,
+  ) {}
+
+  async validateCreateDto(
+    modelName: string,
+    dto: object,
+  ): Promise<void> {
+    const model = await this.modelMetadataService.findOneBySingularName(
+      modelName,
+      { fields: true },
+    );
+
+    for (const field of model.fields ?? []) {
+      const value = (dto as Record<string, unknown>)[field.name];
+
+      if (!isNotEmpty(value) || typeof value !== "string") {
+        continue;
+      }
+
+      if (!isNotEmpty(field.regexPattern)) {
+        continue;
+      }
+
+      if (!matches(value, new RegExp(field.regexPattern))) {
+        throw new BadRequestException(
+          field.regexPatternNotMatchingErrorMsg ||
+            `Validation errors in ${field.name} is invalid i.e Field regex pattern is invalid`,
+        );
+      }
+    }
+  }
+}

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

@@ -1729,7 +1729,10 @@ export class ModelMetadataService {
     // --------------------
     // Find record index in page
     // --------------------
-    const index = records.findIndex(r => String(r.id) === String(recordId));
+    const index = records.findIndex(r =>
+      String(r.id) === String(recordId) ||
+      (r.initialEntityVersionId && String(r.initialEntityVersionId) === String(recordId))
+    );
 
     if (index === -1) {
       throw new BadRequestException(`Record not found in current page`);

package/src/services/object.utils.ts

@@ -0,0 +1,10 @@
+// Some filter/sort DTOs arrive with bracket-wrapped keys (e.g. "[isPublished]") from
+// query-string parsing. Both CrudHelperService and DraftPublishHelperService need to
+// strip that wrapping before reading keys, so it lives here as a shared utility.
+export function normalizeObjectKeys(obj: any): any {
+    return Object.keys(obj).reduce((acc, key) => {
+        const newKey = key.replace(/^\[(.*)\]$/, '$1');
+        acc[newKey] = obj[key];
+        return acc;
+    }, {});
+}

package/src/services/settings/default-settings-provider.service.ts

@@ -10,6 +10,13 @@ import {
 export const DEFAULT_MEDIA_UPLOAD_DIR = "media-uploads";
 export const DEFAULT_MEDIA_FILE_STORAGE_DIR = "media-files-storage";
 
+// Seeded setting values are written once and never overwritten, so an unparseable
+// env var would persist. Fall back whenever it is missing or not a positive number.
+const timeoutFromEnv = (value: string | undefined, fallback: number): number => {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+};
+
 // 1.
 const getSolidCoreSettings = (isProd: boolean) =>
   [
@@ -125,10 +132,10 @@ const getSolidCoreSettings = (isProd: boolean) =>
     },
     {
       moduleName: "solid-core",
-      key: "rowClickAction",
+      key: "recordClickAction",
       value: "edit",
       level: SettingLevel.SystemAdminEditable,
-      label: "Row Click Action",
+      label: "Record Click Action",
       group: "app-settings",
       sortOrder: 45,
       controlType: "selectionStatic",
@@ -136,7 +143,7 @@ const getSolidCoreSettings = (isProd: boolean) =>
         { label: "Edit", value: "edit" },
         { label: "View", value: "view" },
       ],
-      helpText: "Decides whether clicking a list row opens the record in edit mode or view mode.",
+      helpText: "Decides whether clicking a record in List, Card, Kanban, or Tree View opens it in edit mode or view mode.",
     },
     {
       moduleName: "solid-core",
@@ -1474,6 +1481,31 @@ const getSolidCoreSettings = (isProd: boolean) =>
       value: process.env.COMMON_META_WHATSAPP_APP_SECRET,
       level: SettingLevel.SystemEnv,
     },
+    {
+      moduleName: "solid-core",
+      key: "uiTestDefaultTimeoutMs",
+      value: timeoutFromEnv(process.env.COMMON_UI_TEST_DEFAULT_TIMEOUT_MS, 30000),
+      level: SettingLevel.SystemAdminEditable,
+      label: "UI Test Default Timeout (ms)",
+      group: "testing-settings",
+      sortOrder: 10,
+      controlType: "numeric",
+      helpText: "How long UI test steps wait for an element before failing. Raise this if tests time out on slow screens. Overridden by the --ui-timeout-ms flag and by a per-step timeoutMs.",
+    },
+    {
+      moduleName: "solid-core",
+      key: "uiTestNavigationTimeoutMs",
+      value: timeoutFromEnv(
+        process.env.COMMON_UI_TEST_NAVIGATION_TIMEOUT_MS,
+        timeoutFromEnv(process.env.COMMON_UI_TEST_DEFAULT_TIMEOUT_MS, 30000),
+      ),
+      level: SettingLevel.SystemAdminEditable,
+      label: "UI Test Navigation Timeout (ms)",
+      group: "testing-settings",
+      sortOrder: 20,
+      controlType: "numeric",
+      helpText: "How long the ui.goto step waits for a page to load before failing. Falls back to the UI test default timeout.",
+    },
   ] as const satisfies SettingDefinition[];
 
 // 2.

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

@@ -15,6 +15,7 @@ import { IS_DASHBOARD_WIDGET_DATA_PROVIDER } from 'src/decorators/dashboard-widg
 import { IS_EXTENSION_USER_CREATION_PROVIDER } from 'src/decorators/extension-user-creation-provider.decorator';
 import { IS_SOLID_DATABASE_MODULE } from 'src/decorators/solid-database-module.decorator';
 import { IS_WA_PROVIDER } from 'src/decorators/whatsapp-provider.decorator';
+import { IS_WORKFLOW_FIELD_DATA_PROVIDER } from 'src/decorators/workflow-field-data-provider.decorator';
 import { SolidRegistry } from 'src/helpers/solid-registry';
 import { AuditSubscriber } from 'src/subscribers/audit.subscriber';
 import { ComputedEntityFieldSubscriber } from 'src/subscribers/computed-entity-field.subscriber';
@@ -69,6 +70,12 @@ export class SolidIntrospectService implements OnApplicationBootstrap {
       this.solidRegistry.registerSelectionProvider(selectionProvider);
     });
 
+    // Register all IWorkflowFieldDataProvider implementations
+    const workflowFieldDataProviders = this.discoveryService.getProviders().filter((provider) => this.isWorkflowFieldDataProvider(provider));
+    workflowFieldDataProviders.forEach((provider) => {
+      this.solidRegistry.registerWorkflowFieldDataProvider(provider);
+    });
+
     // Register all IDashboardWidgetDataProvider implementations
     const dashboardWidgetDataProviders = this.discoveryService.getProviders().filter((provider) => this.isDashboardWidgetDataProvider(provider));
     dashboardWidgetDataProviders.forEach((provider) => {
@@ -277,6 +284,18 @@ export class SolidIntrospectService implements OnApplicationBootstrap {
     return !!isSelectionProvider;
   }
 
+  private isWorkflowFieldDataProvider(provider: InstanceWrapper) {
+    const { instance } = provider;
+    if (!instance) return false;
+
+    const isWorkflowFieldDataProvider = this.reflector.get<boolean>(
+      IS_WORKFLOW_FIELD_DATA_PROVIDER,
+      instance.constructor,
+    );
+
+    return !!isWorkflowFieldDataProvider;
+  }
+
   private isDashboardWidgetDataProvider(provider: InstanceWrapper) {
     const { instance } = provider;
     if (!instance) return false;

package/src/services/user.service.ts

@@ -156,10 +156,25 @@ export class UserService extends CRUDService<User> {
     if (!user) {
       throw new Error(ERROR_MESSAGES.USER_NOT_FOUND);
     }
-    if (updateDto.roles != null) {
-      await this.addRolesToUser(user.username, updateDto.roles);
+
+    const { roles, ...userUpdateDto } = updateDto || {};
+    const savedUser = await this.update(
+      id,
+      userUpdateDto,
+      files,
+      true,
+      solidRequestContext,
+    );
+
+    if (roles != null) {
+      await this.addRolesToUser(savedUser.username, roles);
+      return this.repo.findOne({
+        where: { id: savedUser.id },
+        relations: { roles: true },
+      });
     }
-    await this.update(id, updateDto, files, true);
+
+    return savedUser;
   }
 
   async addRoleToUser(username: string, roleName: string): Promise<User> {

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

@@ -4,8 +4,6 @@ import { InjectEntityManager } from '@nestjs/typeorm';
 import { CRUDService } from 'src/services/crud.service';
 import { EntityManager } from 'typeorm';
 
-import { classify } from '../helpers/string.helper';
-import { Locale } from 'src/entities/locale.entity';
 import { ModelMetadataHelperService } from 'src/helpers/model-metadata-helper.service';
 import { SolidRegistry } from 'src/helpers/solid-registry';
 import { ModelMetadataRepository } from 'src/repository/model-metadata.repository';
@@ -18,6 +16,7 @@ import { MenuItemMetadataService } from './menu-item-metadata.service';
 import { SolidIntrospectService } from './solid-introspect.service';
 import { UserViewMetadataService } from './user-view-metadata.service';
 import { MenuItemMetadata } from 'src/entities/menu-item-metadata.entity';
+import { IWorkflowFieldDataProviderValues } from 'src/interfaces';
 
 @Injectable()
 export class ViewMetadataService extends CRUDService<ViewMetadata> {
@@ -112,62 +111,88 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
 
   private readonly logger = new Logger(ViewMetadataService.name);
 
-  //for locales 
-  private async getEntityRecordsInAllLocales(
-    modelName: string,
-    id: string,
-    defaultEntityLocaleIdFromQuery?: string
-  ): Promise<{ records: any[], defaultEntityLocaleId: string | null }> {
-    const solidRegistry = await this.moduleRef.get(SolidRegistry, { strict: false });
-    // const currentEntityTarget = solidRegistry.getEntityTarget(this.entityManager, classify(modelName));
-    const currentEntityRepository = this.entityManager.getRepository(classify(modelName));
-
-    // Case 1: Creating a new record with no defaultEntityLocaleId to clone
-    if (id === 'new' && !defaultEntityLocaleIdFromQuery) {
-      this.logger.debug(`Creating new record without cloning from any defaultEntityLocaleId.`);
-      return { records: [], defaultEntityLocaleId: null };
-    }
-
-    // Case 2: Creating a new record and cloning from an existing defaultEntityLocaleId
-    if (id === 'new' && defaultEntityLocaleIdFromQuery) {
-      this.logger.debug(`Creating new record by cloning translations from defaultEntityLocaleId: ${defaultEntityLocaleIdFromQuery}`);
-
-      const records = await currentEntityRepository.find({
-        where: [
-          { defaultEntityLocaleId: defaultEntityLocaleIdFromQuery },
-          { id: defaultEntityLocaleIdFromQuery }
-        ]
-      });
+  private parseJsonObject(value: any): Record<string, any> {
+    if (!value) {
+      return {};
+    }
+
+    if (typeof value === 'object') {
+      return value;
+    }
 
-      this.logger.debug(`Found ${records.length} cloned records for new entity.`);
-      return { records, defaultEntityLocaleId: defaultEntityLocaleIdFromQuery };
+    if (typeof value === 'string') {
+      try {
+        return JSON.parse(value);
+      } catch (error: any) {
+        this.logger.warn(`Unable to parse workflow field provider context: ${error?.message ?? error}`);
+      }
     }
 
-    // Case 3: Editing an existing entity
-    const entityRecord = await currentEntityRepository.findOne({ where: { id } });
+    return {};
+  }
 
-    if (!entityRecord) {
-      this.logger.warn(`No entity found for id ${id}`);
-      return { records: [], defaultEntityLocaleId: null };
+  private async getDefaultWorkflowFieldData(
+    workflowField: FieldMetadata,
+    workflowFieldName: string,
+    fieldsMap: Map<string, FieldMetadata>,
+  ): Promise<IWorkflowFieldDataProviderValues[]> {
+    if (workflowField.type === 'selectionStatic') {
+      return workflowField.selectionStaticValues.map(item => {
+        const [value, label] = item.split(":");
+        return { label, value };
+      });
     }
 
-    const defaultEntityLocaleId = entityRecord.defaultEntityLocaleId || entityRecord.id;
-    if (entityRecord.defaultEntityLocaleId) {
-      this.logger.debug(`Editing translated locale record. Translation root id: ${defaultEntityLocaleId}`);
-    } else {
-      this.logger.debug(`Editing translation root record with id ${defaultEntityLocaleId}`);
+    if (workflowField.type === 'relation' && workflowField.relationType === 'many-to-one') {
+      const comodelCrudService = this.introspectService.getCRUDService(workflowField.relationCoModelSingularName);
+      const data = await comodelCrudService.find({ limit: 100, offset: 0, });
+      const records = data.records ?? [];
+      const workflowFieldMetadata = fieldsMap.get(workflowFieldName);
+      const workflowFieldUserKey = (workflowFieldMetadata as any)?.relationModel?.userKeyField?.name;
+
+      if (!workflowFieldUserKey) {
+        this.logger.warn(`Unable to identify relation user key for workflow field: ${workflowFieldName}`);
+        return [];
+      }
+
+      return records.map(item => ({ label: item[workflowFieldUserKey], value: item['id'] }));
     }
 
-    const records = await currentEntityRepository.find({
-      where: [
-        { defaultEntityLocaleId: defaultEntityLocaleId },
-        { id: defaultEntityLocaleId }
-      ]
-    });
+    return [];
+  }
 
-    this.logger.debug(`Found ${records.length} records in all locales for existing entity.`);
+  private async getWorkflowFieldData(
+    entity: ViewMetadata,
+    workflowField: FieldMetadata,
+    workflowFieldName: string,
+    fieldsMap: Map<string, FieldMetadata>,
+    query: Record<string, any>,
+    activeUser: any,
+  ): Promise<readonly IWorkflowFieldDataProviderValues[]> {
+    const workflowFieldDataProviderName = entity.layout?.attrs?.workflowFieldDataProvider;
+    if (workflowFieldDataProviderName) {
+      const solidRegistry = await this.moduleRef.get(SolidRegistry, { strict: false });
+      const provider = solidRegistry.getWorkflowFieldDataProviderInstance(workflowFieldDataProviderName);
+      if (!provider) {
+        throw new BadRequestException(`Workflow field data provider ${workflowFieldDataProviderName} not found`);
+      }
+
+      return provider.values({
+        entityId: query?.id,
+        modelName: entity.model?.singularName ?? query?.modelName,
+        moduleName: entity.module?.name ?? query?.moduleName,
+        workflowFieldName,
+        workflowField,
+        solidModel: entity.model,
+        solidView: entity,
+        solidFieldsMetadata: Object.fromEntries(fieldsMap),
+        query,
+        providerContext: this.parseJsonObject(entity.layout?.attrs?.workflowFieldDataProviderCtxt),
+        activeUser,
+      });
+    }
 
-    return { records, defaultEntityLocaleId };
+    return this.getDefaultWorkflowFieldData(workflowField, workflowFieldName, fieldsMap);
   }
 
   // START: Custom Service Methods
@@ -331,28 +356,9 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
     }
 
     // 9. Use the resolved workflowField to populate workflow specific metadata.
-    // Check if we were able to resolve an actual workflowField.
-    let solidFormViewWorkflowData = [];
+    let solidFormViewWorkflowData: readonly IWorkflowFieldDataProviderValues[] = [];
     if (viewType === 'form' && workflowField) {
-      // check for type of workflow field. 
-      // for workflowFields of type selectionStatic we simply return the key/values from field metadata AS-IS
-      if (workflowField.type === 'selectionStatic') {
-        solidFormViewWorkflowData = workflowField.selectionStaticValues.map(item => {
-          const [value, label] = item.split(":");
-          return { label, value };
-        });
-      }
-      // for workflowFields of type relation.many-to-one we need to query the co-model, and return data in key/value format.
-      if (workflowField.type === 'relation' && workflowField.relationType === 'many-to-one') {
-        const comodelCrudService = this.introspectService.getCRUDService(workflowField.relationCoModelSingularName);
-        const data = await comodelCrudService.find({ limit: 100, offset: 0, });
-        const records = data.records ?? [];
-        const workflowFieldMetadata = fieldsMap.get(workflowFieldName);
-        const workflowFielUserkey = workflowFieldMetadata['relationModel']['userKeyField']['name'];
-
-        // iterate over the comodel records extracting the label & value. 
-        solidFormViewWorkflowData = records.map(item => ({ 'label': item[workflowFielUserkey], 'value': item['id'] }))
-      }
+      solidFormViewWorkflowData = await this.getWorkflowFieldData(entity, workflowField, workflowFieldName, fieldsMap, query, activeUser);
     }
 
     // 10. If this model supports internationalisation, we need to load the locales applicable with the id of an actual record for each locale if present.
@@ -366,92 +372,12 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
      * ]
      */
 
-    const applicableLocales: any = []
-    // if (entity.model.internationalisation) {
-    //   const allLocales = await this.entityManager.getRepository(Locale).find({});
-
-    //   if (id === 'new') {
-    //     allLocales.forEach(locale => {
-    //       applicableLocales.push({
-    //         locale: locale.locale,
-    //         displayName: locale.displayName,
-    //         isDefault: locale.isDefault ? 'yes' : 'no',
-    //         defaultEntityLocaleId: null,
-    //         entityId: null
-    //       });
-    //     });
-    //   }
-    //   else {
-    //     const defaultLocale = allLocales.find(locale => locale.isDefault);
-    //     this.logger.debug(`Default locale is: ${defaultLocale.locale}`);
-
-    //     // Get hold of the repository for the current model
-    //     const solidRegistry = await this.moduleRef.get(SolidRegistry, { strict: false });
-    //     const currentEntityTarget = solidRegistry.getEntityTarget(this.entityManager, classify(modelName));
-    //     const currentEntityRepository = this.entityManager.getRepository(currentEntityTarget);
-
-    //     // We are in edit mode, the id that is being edited could be a record tagged with the default locale or it could be tagged with a non-default locale.
-    //     const entityRecord = await currentEntityRepository.findOne({
-    //       where: {
-    //         id: id,
-    //       }
-    //     });
-    //     if(entityRecord){
-    //     //  Resolve the default entity locale id....
-    //       let defaultEntityLocaleId = null;
-    //       if (entityRecord.localeName === defaultLocale.locale) {
-    //         defaultEntityLocaleId = entityRecord.id;
-    //         this.logger.debug(`You are editing a record tagged with the default locale: ${entityRecord.localeName}.`);
-    //       }
-    //       else {
-    //         defaultEntityLocaleId = entityRecord.defaultEntityLocaleId;
-    //         this.logger.debug(`You are editing a record tagged with the non-default locale: ${entityRecord.localeName}. `);
-    //       }
-    //       this.logger.debug(`Identified default Entity Locale Id: ${defaultEntityLocaleId}`);
-
-    //       // Now we query for all records in the same model matching the defaultEntityLocaleId
-    //       // Get all records mathcing the defaultEntityLocaleId or where the id is same as the defaultEntityLocaleId
-    //       const entityRecordsInAllLocales = await currentEntityRepository.find({
-    //         where: [
-    //           { defaultEntityLocaleId: defaultEntityLocaleId },
-    //           { id: defaultEntityLocaleId }
-    //         ],
-    //       });
-    //       this.logger.debug(`Found ${entityRecordsInAllLocales.length} records in all locales for the defaultEntityLocaleId: ${defaultEntityLocaleId}`);
-
-    //       // Loop over all locales and populate the applicableLocales array
-    //       for (const locale of allLocales) {
-    //         // Find the record in the entityRecordsInAllLocales that matches the current locale
-    //         const matchingRecord = entityRecordsInAllLocales.find(record => record.localeName === locale.locale);
-
-    //         applicableLocales.push({
-    //           locale: locale.locale,
-    //           displayName: locale.displayName,
-    //           isDefault: locale.isDefault ? 'yes' : 'no',
-    //           defaultEntityLocaleId: defaultEntityLocaleId,
-    //           entityId: (matchingRecord ? matchingRecord.id : null)
-    //         });
-    //       }
-    //     }else{
-    //       this.logger.warn(`No record found for id: ${id} in model: ${modelName}. Cannot determine applicable locales.`);
-    //     }
-    //   }
-    // }
+    let applicableLocales: any[] = [];
     if (entity.model.internationalisation) {
-      const defaultEntityLocaleIdFromQuery = query?.defaultEntityLocaleId;
-      const { records: entityRecordsInAllLocales, defaultEntityLocaleId } =
-        await this.getEntityRecordsInAllLocales(modelName, id, defaultEntityLocaleIdFromQuery);
-      const allLocales = await this.entityManager.getRepository(Locale).find({});
-      for (const locale of allLocales) {
-        const matchingRecord = entityRecordsInAllLocales.find(record => record.localeName === locale.locale);
-        applicableLocales.push({
-          locale: locale.locale,
-          displayName: locale.displayName,
-          isDefault: locale.isDefault ? 'yes' : 'no',
-          defaultEntityLocaleId: defaultEntityLocaleId,
-          entityId: matchingRecord ? matchingRecord.id : null
-        });
-      }
+      const draftPublishEnabled = entity.model.draftPublishWorkflow === true;
+      applicableLocales = await this.internationalisationHelperService.buildApplicableLocales(
+        this.entityManager, modelName, id, query?.defaultEntityLocaleId, draftPublishEnabled,
+      );
     }
 
     const r = {