@solidxai/core 0.1.14 → 0.1.15-beta.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidxai/core",
-  "version": "0.1.14",
+  "version": "0.1.15-beta.0",
   "description": "This module is a NestJS module containing all the required core providers required by a Solid application",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/constants/media-file-types.ts

@@ -238,9 +238,25 @@ export function isDangerousMediaFile(file?: UploadedFileLike | null): boolean {
  * Single source of truth for extension -> coarse media category. Shared by upload-time
  * validation (MediaFieldCrudManager) and serve-time header hardening (ServeStaticModule), so
  * both agree on which extensions belong to which category and neither drifts out of sync.
- * webm/ogg are shared between AUDIO_EXTENSIONS and VIDEO_EXTENSIONS - last one wins here, they
- * default to 'video' since that's the more common upload case.
+ * Some extensions, such as ogg and webm, are valid for more than one category.
+ * Keep every matching category instead of allowing a later entry to overwrite an earlier one.
  */
+// Example: { ogg: ['audio', 'video'], mp3: ['audio'], jpg: ['image'] }
+export const EXT_TO_MEDIA_TYPES: Record<string, MediaCategory[]> = MEDIA_FILE_TYPES.reduce((acc, fileType) => {
+    // Create an empty category list the first time we see an extension.
+    if (!acc[fileType.extension]) {
+        acc[fileType.extension] = [];
+    }
+
+    // Add the category for this extension, but do not add duplicates.
+    if (!acc[fileType.extension].includes(fileType.mediaType)) {
+        acc[fileType.extension].push(fileType.mediaType);
+    }
+
+    // Return the map so the next media definition can be added to it.
+    return acc;
+}, {} as Record<string, MediaCategory[]>);
+
 export const EXT_TO_MEDIA_TYPE: Record<string, MediaCategory> = {
     ...Object.fromEntries(MEDIA_FILE_TYPES.map((fileType) => [fileType.extension, fileType.mediaType])),
 };

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

@@ -1,5 +1,5 @@
 import { FieldCrudManager, ValidationError } from "src/interfaces";
-import { EXT_TO_MEDIA_TYPE, getLowercaseFileExtension, getUploadedFileName, isDangerousMediaFile, MediaCategory, MIME_TO_MEDIA_TYPE } from "src/constants/media-file-types";
+import { EXT_TO_MEDIA_TYPES, getLowercaseFileExtension, getUploadedFileName, isDangerousMediaFile, MediaCategory, MIME_TO_MEDIA_TYPE } from "src/constants/media-file-types";
 
 export enum SolidMediaType {
     mediaSingle = 'mediaSingle',
@@ -40,9 +40,15 @@ export class MediaFieldCrudManager implements FieldCrudManager {
         // 'image', since the mimetype match short-circuited before the extension was ever
         // checked). The extension must independently resolve to a known-safe category before
         // anything is accepted - not merely "not on the denylist".
+        // Read the file extension from the uploaded filename, for example "song.ogg" -> "ogg".
         const ext = getLowercaseFileExtension(getUploadedFileName(file));
-        const extType = ext ? EXT_TO_MEDIA_TYPE[ext] : undefined;
-        if (!extType) {
+
+        // Find every media category that supports this extension.
+        // An extension can belong to multiple categories, for example .ogg can be audio or video.
+        const extToMediaTypes = ext ? EXT_TO_MEDIA_TYPES[ext] : undefined;
+
+        // Reject files whose extension is not part of the supported media definitions.
+        if (!extToMediaTypes || extToMediaTypes.length === 0) {
             return null;
         }
 
@@ -50,13 +56,15 @@ export class MediaFieldCrudManager implements FieldCrudManager {
         // grant a category on its own. A mimetype that doesn't resolve to anything (e.g.
         // application/octet-stream) has no opinion and is treated as agreeing.
         const mt = (file.mimetype || '').toLowerCase().trim();
-        const mimeType = MIME_TO_MEDIA_TYPE[mt]
+        const mimeToMediaTypes = MIME_TO_MEDIA_TYPE[mt]
             ?? (mt.startsWith('image/') ? 'image' : mt.startsWith('audio/') ? 'audio' : mt.startsWith('video/') ? 'video' : undefined);
-        if (mimeType && mimeType !== extType) {
+        // When the extension is shared, the MIME type identifies the actual category:
+        // audio/ogg becomes audio, while video/ogg becomes video.
+        if (mimeToMediaTypes && !extToMediaTypes.includes(mimeToMediaTypes)) {
             return null;
         }
 
-        return extType;
+        return mimeToMediaTypes || extToMediaTypes[0];
     }
 
     validate(dto: any, files: Array<Express.Multer.File>): ValidationError[] {

package/src/helpers/user-helper.ts

@@ -9,6 +9,8 @@ export function getUserExcludedFields(): string[] {
     "googleId",
     "active",
     "forcePasswordChange",
+    "failedLoginAttempts",
+    "isAllowedToGenerateApiKeys",
     "lastLoginProvider",
     "googleProfilePicture",
     "facebookAccessToken",

package/src/services/import-transaction.service.ts

@@ -643,9 +643,44 @@ export class ImportTransactionService extends CRUDService<ImportTransaction> {
         }
       }
     }
+
+    // Some fields are hidden from the import file because users should not
+    // have to enter internal values such as passwordSchemeVersion. The
+    // backend still checks those fields as required, so fill in their default
+    // values here before validation. This lets users import normal details
+    // without exposing or requiring internal fields in the template.
+    for (const field of modelMetadataWithFields.fields) {
+      if (
+        field.required &&
+        field.defaultValue !== null &&
+        field.defaultValue !== undefined &&
+        !(field.name in dtoRecord)
+      ) {
+        dtoRecord[field.name] = this.parseImportDefaultValue(field);
+      }
+    }
+
     return dtoRecord;
   }
 
+  // Defaults come from metadata as text. Convert them to the type expected by
+  // validation, so values like "1" and "true" are handled as a number and a
+  // boolean instead of being treated as plain text.
+  private parseImportDefaultValue(field: FieldMetadata): any {
+    const defaultValue = field.defaultValue;
+
+    switch (field.type) {
+      case SolidFieldType.boolean:
+        return ['true', '1', 'yes'].includes(String(defaultValue).toLowerCase());
+      case SolidFieldType.int:
+      case SolidFieldType.bigint:
+      case SolidFieldType.decimal:
+        return Number(defaultValue);
+      default:
+        return defaultValue;
+    }
+  }
+
   private async populateDtoForACell(dtoRecord: Record<string, any>, fieldMetadata: FieldMetadata, record: Record<string, any>, key: string): Promise<Record<string, any>> {
     const fieldType = fieldMetadata.type;
     // const userKeyFieldName = userKeyField?.name || 'id'; // Default to 'id' if not found