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

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

@@ -125,10 +125,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 +136,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",

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';
@@ -197,64 +195,6 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
     return this.getDefaultWorkflowFieldData(workflowField, workflowFieldName, fieldsMap);
   }
 
-  //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 }
-        ]
-      });
-
-      this.logger.debug(`Found ${records.length} cloned records for new entity.`);
-      return { records, defaultEntityLocaleId: defaultEntityLocaleIdFromQuery };
-    }
-
-    // Case 3: Editing an existing entity
-    const entityRecord = await currentEntityRepository.findOne({ where: { id } });
-
-    if (!entityRecord) {
-      this.logger.warn(`No entity found for id ${id}`);
-      return { records: [], defaultEntityLocaleId: null };
-    }
-
-    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}`);
-    }
-
-    const records = await currentEntityRepository.find({
-      where: [
-        { defaultEntityLocaleId: defaultEntityLocaleId },
-        { id: defaultEntityLocaleId }
-      ]
-    });
-
-    this.logger.debug(`Found ${records.length} records in all locales for existing entity.`);
-
-    return { records, defaultEntityLocaleId };
-  }
-
   // START: Custom Service Methods
   async getLayout(query, activeUser) {
     let { modelName, moduleName, viewType, id, populate, menuItemId, menuItemName, actionId, actionName } = query;
@@ -432,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 = {

package/src/solid-core.module.ts

@@ -38,6 +38,8 @@ import { MqDashboardQueueNameVariableOptionsProvider } from "./services/selectio
 import { PseudoForeignKeySelectionProvider } from "./services/selection-providers/pseudo-foreign-key-selection-provider.service";
 import { ModuleMetadataSeederService } from "./seeders/module-metadata-seeder.service";
 import { ModuleTestDataService } from "./seeders/module-test-data.service";
+import { DraftPublishHelperService } from "./services/draft-publish-helper.service";
+import { InternationalisationHelperService } from "./services/internationalisation-helper.service";
 import { CrudHelperService } from "./services/crud-helper.service";
 import { DatasourceManagementService } from "./services/datasource-management.service";
 import { DatasourceIntrospectionService } from "./services/datasource-introspection.service";
@@ -56,10 +58,10 @@ import { ModulePackageService } from "./services/module-package.service";
 import { SolidIntrospectService } from "./services/solid-introspect.service";
 // import { ListOfComputedFieldProvider } from './providers/list-of-computed-field-provider.service';
 import { ServeStaticModule } from "@nestjs/serve-static";
-import { extname, join } from "path";
+import { basename, join } from "path";
 import { RefreshModelCommand } from "./commands/refresh-model.command";
 import { MediaController } from "./controllers/media.controller";
-import { INLINE_SAFE_EXTENSIONS } from "./constants/media-file-types";
+import { getLowercaseFileExtension, INLINE_SAFE_EXTENSIONS } from "./constants/media-file-types";
 
 import { RefreshModuleCommand } from "./commands/refresh-module.command";
 import { ModelMetadataSubscriber } from "./subscribers/model-metadata.subscriber";
@@ -167,6 +169,7 @@ import { GoogleOauthStrategy } from "./passport-strategies/google-oauth.strategy
 import { ApiKeyService } from "./services/api-key.service";
 import { ActiveSessionStorageService } from "./services/active-session-storage.service";
 import { AuthenticationService } from "./services/authentication.service";
+import { MetadataValidationService } from "./services/metadata-validation.service";
 import { BcryptService } from "./services/bcrypt.service";
 import { UuidExternalIdEntityComputedFieldProvider } from "./services/computed-fields/entity/uuid-externalid-entity-computed-field-provider.service";
 import { UuidExternalIdComputedFieldProvider } from "./services/computed-fields/uuid-external-id-computed-field-provider.service";
@@ -535,7 +538,11 @@ import { SwitchNode } from './services/workflow/nodes/switch.node';
           // else (including svg, html, and any other uploaded file) is forced to download
           // rather than be displayed/executed by the browser, regardless of what mimetype or
           // extension it was uploaded with.
-          if (!INLINE_SAFE_EXTENSIONS.has(extname(path).toLowerCase().replace(/^\./, ''))) {
+          // basename first: getLowercaseFileExtension takes a file name, not a path, so a
+          // directory containing a dot must not be mistaken for the extension. An
+          // extensionless file yields undefined, which is not inline-safe - so it correctly
+          // falls through to the forced-download branch.
+          if (!INLINE_SAFE_EXTENSIONS.has(getLowercaseFileExtension(basename(path)) ?? '')) {
             res.setHeader("Content-Type", "application/octet-stream");
             res.setHeader("Content-Disposition", "attachment");
           }
@@ -644,6 +651,7 @@ import { SwitchNode } from './services/workflow/nodes/switch.node';
     ModuleMetadataExplorerService,
     ModuleMetadataHelperService,
     ModulePackageService,
+    MetadataValidationService,
     ModelMetadataService,
     ModelMetadataHelperService,
     FieldMetadataService,
@@ -656,6 +664,8 @@ import { SwitchNode } from './services/workflow/nodes/switch.node';
     InfoService,
     SolidIntrospectService,
     DiscoveryService,
+    DraftPublishHelperService,
+    InternationalisationHelperService,
     CrudHelperService,
     CRUDService,
     Reflector,
@@ -976,6 +986,8 @@ import { SwitchNode } from './services/workflow/nodes/switch.node';
     ChatterMessageRepository,
     ChatterMessageService,
     ConfigModule,
+    DraftPublishHelperService,
+    InternationalisationHelperService,
     CrudHelperService,
     CRUDService,
     CsvService,
@@ -998,6 +1010,7 @@ import { SwitchNode } from './services/workflow/nodes/switch.node';
     SmsFactory,
     MediaService,
     MediaStorageProviderMetadataService,
+    MetadataValidationService,
     ModelMetadataHelperService,
     ModelMetadataService,
     ModuleMetadataService,