@solidstarters/solid-core 1.2.202 → 1.2.204

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidstarters/solid-core",
-  "version": "1.2.202",
+  "version": "1.2.204",
   "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/dtos/create-role-metadata.dto.ts

@@ -91,6 +91,9 @@ export const INTERNAL_ROLE_PERMISSIONS = [
     'AuthenticationController.logout',
     'AuthenticationController.me',
 
+    // Field Metadata permissions
+    'ModelMetadataController.navigation',
+
     // Field Metadata permissions
     'FieldMetadataController.getSelectionDynamicValues',
     'FieldMetadataController.getSelectionDynamicValue',

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

@@ -9,20 +9,122 @@ export interface MediaFieldOptions {
     type: SolidMediaType;
     required: boolean | undefined | null;
     fieldName: string | undefined | null;
+    mediaMaxSizeKb: number | undefined | null;
+    mediaTypes: string[];
 }
 
+type MediaType = 'image' | 'audio' | 'video' | 'file';
+
+const MIME_TO_MEDIA_TYPE: Record<string, MediaType> = {
+    // Images
+    'image/png': 'image',
+    'image/jpeg': 'image',
+    'image/jpg': 'image',
+    'image/webp': 'image',
+    'image/gif': 'image',
+    'image/bmp': 'image',
+    'image/tiff': 'image',
+    'image/svg+xml': 'image',
+    'image/heic': 'image',
+    'image/heif': 'image',
+
+    // Audio
+    'audio/mpeg': 'audio',      // mp3
+    'audio/mp3': 'audio',
+    'audio/wav': 'audio',
+    'audio/x-wav': 'audio',
+    'audio/webm': 'audio',
+    'audio/ogg': 'audio',
+    'audio/aac': 'audio',
+    'audio/mp4': 'audio',       // m4a often shows as audio/mp4
+    'audio/x-m4a': 'audio',
+    'audio/flac': 'audio',
+
+    // Video
+    'video/mp4': 'video',
+    'video/mpeg': 'video',
+    'video/webm': 'video',
+    'video/ogg': 'video',
+    'video/quicktime': 'video', // mov
+    'video/x-msvideo': 'video', // avi
+    'video/x-matroska': 'video',// mkv
+    'video/3gpp': 'video',
+    'video/3gpp2': 'video',
+
+    // Documents / files (treat as "file")
+    'application/pdf': 'file',
+    'text/plain': 'file',
+    'text/markdown': 'file',
+    'application/json': 'file',
+    'text/csv': 'file',
+
+    // Office
+    'application/msword': 'file', // doc
+    'application/vnd.openxmlformats-officedocument.wordprocessingml.document': 'file', // docx
+    'application/vnd.ms-excel': 'file', // xls
+    'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': 'file', // xlsx
+    'application/vnd.ms-powerpoint': 'file', // ppt
+    'application/vnd.openxmlformats-officedocument.presentationml.presentation': 'file', // pptx,
+
+    // Archives (optional)
+    'application/zip': 'file',
+    'application/x-zip-compressed': 'file',
+    'application/x-rar-compressed': 'file',
+    'application/x-7z-compressed': 'file',
+
+    // Common binary fallback category
+    'application/octet-stream': 'file',
+};
+
+const EXT_TO_MEDIA_TYPE: Record<string, MediaType> = {
+    // Images
+    png: 'image', jpg: 'image', jpeg: 'image', webp: 'image', gif: 'image', bmp: 'image', tiff: 'image', svg: 'image', heic: 'image', heif: 'image',
+
+    // Audio
+    mp3: 'audio', wav: 'audio', ogg: 'audio', aac: 'audio', m4a: 'audio', flac: 'audio',
+
+    // Video
+    mp4: 'video', mov: 'video', avi: 'video', mkv: 'video', mpeg: 'video', mpg: 'video', '3gp': 'video', '3g2': 'video',
+
+    // Files
+    pdf: 'file', txt: 'file', md: 'file', csv: 'file', json: 'file',
+    doc: 'file', docx: 'file', xls: 'file', xlsx: 'file', ppt: 'file', pptx: 'file',
+    zip: 'file', rar: 'file', '7z': 'file',
+};
+
+
 export class MediaFieldCrudManager implements FieldCrudManager {
 
     constructor(private readonly options: MediaFieldOptions) {
     }
 
-    validate(dto: any, files:Array<Express.Multer.File>): ValidationError[] {
+    private resolveMediaType(mimetype?: string, filename?: string): MediaType | null {
+        const mt = (mimetype || '').toLowerCase().trim();
+        if (mt && MIME_TO_MEDIA_TYPE[mt]) {
+            return MIME_TO_MEDIA_TYPE[mt];
+        }
+
+        // Some libs may send "image/*" etc. Treat broad families safely.
+        if (mt.startsWith('image/')) return 'image';
+        if (mt.startsWith('audio/')) return 'audio';
+        if (mt.startsWith('video/')) return 'video';
+
+        // Fallback to extension if provided
+        const ext = (filename || '').split('.').pop()?.toLowerCase();
+        if (ext && EXT_TO_MEDIA_TYPE[ext]) {
+            return EXT_TO_MEDIA_TYPE[ext];
+        }
+
+        return null;
+    }
+
+    validate(dto: any, files: Array<Express.Multer.File>): ValidationError[] {
         const isValidateForUpdate = dto.id !== undefined; //FIXME: This is a hack, since we are using PUT for update. Once we support PATCH, this will be removed
         const fieldFiles = files.filter(file => file.fieldname === this.options.fieldName);
         return this.applyValidations(fieldFiles, isValidateForUpdate);
     }
 
-    private applyValidations(fieldFiles:Array<Express.Multer.File>, isValidateForUpdate: boolean): ValidationError[] {
+    private applyValidations(fieldFiles: Array<Express.Multer.File>, isValidateForUpdate: boolean): ValidationError[] {
         switch (this.options.type) {
             case SolidMediaType.mediaSingle:
                 return this.validateMediaSingle(fieldFiles, isValidateForUpdate);
@@ -33,7 +135,7 @@ export class MediaFieldCrudManager implements FieldCrudManager {
         }
     }
 
-    private validateMediaSingle(fieldFiles:Array<Express.Multer.File>, isValidateForUpdate: boolean): ValidationError[] {
+    private validateMediaSingle(fieldFiles: Array<Express.Multer.File>, isValidateForUpdate: boolean): ValidationError[] {
         const errors: ValidationError[] = [];
         if (!isValidateForUpdate && this.options.required && fieldFiles.length === 0) {
             errors.push({
@@ -47,10 +149,42 @@ export class MediaFieldCrudManager implements FieldCrudManager {
                 error: `${this.options.fieldName} must be a single file`
             });
         }
+        // validate size
+        if (this.options.mediaMaxSizeKb) {
+            for (let i = 0; i < fieldFiles.length; i++) {
+                const fieldFile = fieldFiles[i];
+                const fieldFileSizeInBytes = Math.ceil(fieldFile.size / 1024);
+                if (fieldFileSizeInBytes > this.options.mediaMaxSizeKb) {
+                    errors.push({
+                        field: this.options.fieldName,
+                        error: `${this.options.fieldName} with size ${fieldFileSizeInBytes} KB exceeds max size limit of ${this.options.mediaMaxSizeKb} KB`
+                    });
+                }
+            }
+        }
+        // validate type
+        if (this.options.mediaTypes && this.options.mediaTypes.length > 0) {
+            const allowedFileTypes = this.options.mediaTypes as MediaType[];
+
+            for (let i = 0; i < fieldFiles.length; i++) {
+                const fieldFile = fieldFiles[i];
+
+                const resolvedType = this.resolveMediaType(fieldFile.mimetype, fieldFile.originalname ?? fieldFile.filename ?? '');
+                if (!resolvedType || !allowedFileTypes.includes(resolvedType)) {
+                    errors.push({
+                        field: this.options.fieldName,
+                        error: `${this.options.fieldName} file type not allowed. ` +
+                            `Allowed: ${allowedFileTypes.join(', ')}. ` +
+                            `Received mimetype: ${fieldFile.mimetype}${resolvedType ? ` (mapped to ${resolvedType})` : ''}`
+                    });
+                }
+            }
+        }
+
         return errors;
     }
 
-    private validateMediaMultiple(fieldFiles:Array<Express.Multer.File>, isValidateForUpdate: boolean): ValidationError[] {    
+    private validateMediaMultiple(fieldFiles: Array<Express.Multer.File>, isValidateForUpdate: boolean): ValidationError[] {
         const errors: ValidationError[] = [];
         if (!isValidateForUpdate && this.options.required && fieldFiles.length === 0) {
             errors.push({

package/src/helpers/image-encoding.helper.ts

@@ -0,0 +1,71 @@
+import { Injectable, Logger } from '@nestjs/common';
+
+export interface ImageToBase64Result {
+    base64: string;
+    mediaType: string;
+}
+
+@Injectable()
+export class ImageEncodingService {
+    private readonly logger = new Logger(ImageEncodingService.name);
+
+    /**
+     * Fetch an image from a URL and return its Base64 representation.
+     *
+     * @param url - Public or signed image URL
+     * @param mimeTypeOverride - Optional MIME type (image/png, image/jpeg)
+     * @param maxSizeBytes - Optional max size guard (default 5MB)
+     */
+    async imageUrlToBase64(
+        url: string,
+        mimeTypeOverride?: string,
+        maxSizeBytes = 5 * 1024 * 1024, 
+    ): Promise<ImageToBase64Result> {
+        this.logger.debug(`Fetching image from URL: ${url}`);
+
+        const response = await fetch(url);
+
+        if (!response.ok) {
+            throw new Error(
+                `Failed to fetch image (${response.status} ${response.statusText})`,
+            );
+        }
+
+        const contentType =
+            mimeTypeOverride ||
+            response.headers.get('content-type') ||
+            'image/jpeg';
+
+        const arrayBuffer = await response.arrayBuffer();
+        const buffer = Buffer.from(arrayBuffer);
+
+        if (buffer.length > maxSizeBytes) {
+            throw new Error(
+                `Image size ${buffer.length} bytes exceeds limit of ${maxSizeBytes} bytes`,
+            );
+        }
+
+        return {
+            base64: buffer.toString('base64'),
+            mediaType: contentType,
+        };
+    }
+
+    /**
+     * Convenience method that returns a data URL
+     * (useful for OpenAI Responses API).
+     */
+    async imageUrlToDataUrl(
+        url: string,
+        mimeTypeOverride?: string,
+        maxSizeBytes?: number,
+    ): Promise<string> {
+        const { base64, mediaType } = await this.imageUrlToBase64(
+            url,
+            mimeTypeOverride,
+            maxSizeBytes,
+        );
+
+        return `data:${mediaType};base64,${base64}`;
+    }
+}

package/src/helpers/module.helper.ts

@@ -32,6 +32,8 @@ export const getDynamicModuleNames = (): string[] => {
     .map(dirent => dirent.name);
 
   // logger.debug(`Enabled dynamic modules:`, enabledModules);
+  console.log(`Dynamic Modules Are:`, enabledModules);
+
   return enabledModules;
 }
 
@@ -65,6 +67,7 @@ export const getDynamicModuleNamesBasedOnMetadata = (): string[] => {
     .map(dirent => dirent.name);
 
   // logger.debug(`Enabled dynamic modules basis src:`, enabledModules);
+  console.log(`Src Based Dynamic Modules Are:`, enabledModules);
   return enabledModules;
 }
 

package/src/helpers/solid-microservice-adapter.service.ts

@@ -0,0 +1,68 @@
+import { Injectable, Logger, Scope } from '@nestjs/common';
+import axios from 'axios';
+
+export interface SolidxIamAuthRequest {
+  email?: string;
+  username?: string;
+  password: string;
+}
+
+export interface SolidxIamUser {
+  email: string;
+  mobile: string;
+  username: string;
+  forcePasswordChange: boolean;
+  id: number;
+  roles: string[];
+}
+
+export interface SolidxIamAuthData {
+  user: SolidxIamUser;
+  accessToken: string;
+  refreshToken: string;
+}
+
+export interface SolidxIamAuthResponse {
+  statusCode: number;
+  message: string[];
+  error: string;
+  data: SolidxIamAuthData;
+}
+
+@Injectable({ scope: Scope.TRANSIENT })
+export class SolidMicroserviceAdapter {
+  private readonly logger = new Logger(SolidMicroserviceAdapter.name);
+  private baseUrl?: string;
+
+  setBaseUrl(baseUrl: string): this {
+    this.baseUrl = baseUrl;
+    return this;
+  }
+
+  async authenticate({ email, username, password }: SolidxIamAuthRequest): Promise<SolidxIamAuthResponse> {
+    if (!password) {
+      throw new Error('password is required for IAM authentication');
+    }
+    if (!email && !username) {
+      throw new Error('email or username is required for IAM authentication');
+    }
+    if (!this.baseUrl) {
+      throw new Error('baseUrl must be set before IAM authentication');
+    }
+
+    const payload: SolidxIamAuthRequest = { password };
+    if (email) payload.email = email;
+    if (username) payload.username = username;
+
+    this.logger.debug(`Requesting IAM access token from ${this.baseUrl}/api/iam/authenticate`);
+
+    const response = await axios.post(`${this.baseUrl}/api/iam/authenticate`, payload, {
+      timeout: 10000,
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    });
+
+    return response.data as SolidxIamAuthResponse;
+  }
+}

package/src/index.ts

@@ -178,6 +178,8 @@ export * from './helpers/environment.helper'
 export * from './helpers/cors.helper'
 export * from './helpers/security.helper'
 export * from './helpers/model-metadata-helper.service'
+export * from './helpers/image-encoding.helper'
+export * from './helpers/solid-microservice-adapter.service'
 
 export * from './services/crud.service'
 export * from './interceptors/logging.interceptor'

package/src/mappers/list-of-values-mapper.ts

@@ -11,7 +11,8 @@ export class ListOfValuesMapper {
             description: listOfValue.description,
             default: listOfValue.default,
             sequence: listOfValue.sequence,
-            module: listOfValue.module ? listOfValue.module.id : null
+            // module: listOfValue.module ? listOfValue.module.id : null
+            moduleUserKey: listOfValue.module ? listOfValue.module.name : null
         };
     }
 }

package/src/repository/security-rule.repository.ts

@@ -43,6 +43,9 @@ export class SecurityRuleRepository extends SolidBaseRepository<SecurityRule> {
                 if (rule.securityRuleConfigProvider) {
                     // TODO: Evaluation of the securityRuleConfig Provider should happen outside first...
                     const securityRuleConfigProviderInstance = this.solidRegistry.getSecurityRuleConfigProviderInstance(rule.securityRuleConfigProvider);
+                    if (!securityRuleConfigProviderInstance) {
+                        throw new Error(`Unable to resolve instance for security rule config provider: ${rule.securityRuleConfigProvider}`);
+                    }
                     evaluatedRule = await securityRuleConfigProviderInstance.securityRuleConfig(activeUser, rule);
                 }
                 else {
@@ -54,7 +57,9 @@ export class SecurityRuleRepository extends SolidBaseRepository<SecurityRule> {
                 evaluatedRules.push(evaluatedRule);
 
             } catch (error) {
-                this.logger.warn(`Error parsing security rule: ${rule.securityRuleConfig}`, error);
+                this.logger.error(`Error parsing security rule: ${rule.securityRuleConfig}`, error);
+                this.logger.error(error.stack);
+                throw error;
             }
         }
 
@@ -104,7 +109,7 @@ export class SecurityRuleRepository extends SolidBaseRepository<SecurityRule> {
             modelMetadataId: populatedSecurityRule.modelMetadata.id,
             modelMetadataUserKey: populatedSecurityRule.modelMetadata.singularName,
             securityRuleConfig: populatedSecurityRule.securityRuleConfig,
-            securityRuleConfigProvider: ""
+            securityRuleConfigProvider: populatedSecurityRule.securityRuleConfigProvider,
         };
     }
 

package/src/seeders/module-metadata-seeder.service.ts

@@ -196,7 +196,9 @@ export class ModuleMetadataSeederService {
         // Setup default roles with permissions.
         await this.setupDefaultRolesWithPermissions();
 
-        this.logger.log(`All Seeders finished`);
+        // Add a console log indicating seeding is finished. This needs to be console.log so that it looks proper when this code is run via CLI.
+        console.log(`Seeding completed.`);
+        //this.logger.log(`All Seeders finished`);
 
         //FIXME: Handle displaying the created users credentials in a better way.
         // this.logger.log(`Newly created username is: ${usersDetail?.length > 0 ? usersDetail[0]?.username : ''} and password is ${usersDetail?.length > 0 ? usersDetail[0]?.password : ''}`);

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

@@ -8980,6 +8980,13 @@
               "widget": "SolidUserNameAvatarWidget"
             }
           },
+          {
+            "type": "field",
+            "attrs": {
+              "name": "fullName",
+              "isSearchable": true
+            }
+          },
           {
             "type": "field",
             "attrs": {
@@ -11013,6 +11020,22 @@
               "sortable": true,
               "filterable": true
             }
+          },
+          {
+            "type": "field",
+            "attrs": {
+              "name": "event",
+              "sortable": true,
+              "filterable": true
+            }
+          },
+          {
+            "type": "field",
+            "attrs": {
+              "name": "ipAddress",
+              "sortable": true,
+              "filterable": true
+            }
           }
         ]
       }
@@ -11057,6 +11080,24 @@
                         "attrs": {
                           "name": "user"
                         }
+                      },
+                      {
+                        "type": "field",
+                        "attrs": {
+                          "name": "event"
+                        }
+                      },
+                      {
+                        "type": "field",
+                        "attrs": {
+                          "name": "ipAddress"
+                        }
+                      },
+                      {
+                        "type": "field",
+                        "attrs": {
+                          "name": "userAgent"
+                        }
                       }
                     ]
                   },

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

@@ -176,7 +176,7 @@ export class AuthenticationService {
             const savedUser = await this.userRepository.save(user);
             // Also assign a default role to the newly created user. 
             const userRoles = signUpDto.roles ?? [];
-            if (this.iamConfiguration.defaultRole) {
+            if (signUpDto.username !== 'sa' && this.iamConfiguration.defaultRole) {
                 userRoles.push(this.iamConfiguration.defaultRole);
             }
             await this.handlePostSignup(savedUser, userRoles, pwd, autoGeneratedPwd);
@@ -842,14 +842,16 @@ export class AuthenticationService {
         }
 
         // Update Password
-        const newPwd = await this.hashingService.hash(changePasswordDto.newPassword);
+        const pwdData = await this.userService.hashPassword(
+            changePasswordDto.newPassword,
+        );
         user.password = changePasswordDto.newPassword;
-        user.passwordScheme = this.hashingService.name(); // e.g. bcrypt
-        user.passwordSchemeVersion = this.hashingService.currentVersion(); // e.g. 1, 2, 3 ...
 
+        user.password = pwdData.password;
+        user.passwordScheme = pwdData.passwordScheme;
+        user.passwordSchemeVersion = pwdData.passwordSchemeVersion;
         // Everytime the user changes the password we reset the forcePasswordChange flag back to false. 
         user.forcePasswordChange = false;
-        user.password = newPwd;
 
         await this.userRepository.save(user);
 

package/src/services/crud.service.ts

@@ -339,7 +339,12 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
                 //    Use the EntityController to extract uploaded content & pass to the entity service.
                 //    If embedded media, then the media uri will saved in the entity table, else the uri will be saved in the media table
                 //    Plan the media table schema e.g id, uri, storageProvider, entity_id, entity_name, createdAt, updatedAt
-                const options = { ...commonOptions, type: fieldMetadata.type as unknown as SolidMediaType };
+                const options = { 
+                    ...commonOptions, 
+                    mediaMaxSizeKb: fieldMetadata.mediaMaxSizeKb,
+                    mediaTypes: fieldMetadata.mediaTypes,
+                    type: fieldMetadata.type as unknown as SolidMediaType 
+                };
                 return new MediaFieldCrudManager(options);
             }
             case SolidFieldType.relation: {

package/src/services/selection-providers/list-of-roles-selectionproviders.service.ts

@@ -0,0 +1,69 @@
+import { Injectable, BadRequestException } from "@nestjs/common";
+import { SelectionProvider } from "src/decorators/selection-provider.decorator";
+import {
+  ISelectionProvider,
+  ISelectionProviderContext,
+  ISelectionProviderValues
+} from "../../interfaces";
+import { BasicFilterDto } from "src/dtos/basic-filters.dto";
+import { RoleMetadataService } from "../role-metadata.service";
+
+const DEFAULT_LIMIT = 100;
+
+interface ListOfRolesProviderContext extends ISelectionProviderContext {
+    filters?: Record<string, any>;
+
+}
+
+@SelectionProvider()
+@Injectable()
+export class ListOfRolesSelectionProvider implements ISelectionProvider<ListOfRolesProviderContext> {
+
+    constructor(
+        private readonly roleMetadataService: RoleMetadataService
+    ) {}
+
+    name(): string {
+        return 'ListOfRolesSelectionProvider';
+    }
+
+    help(): string {
+        return '# Simple Role selection provider (search + include/exclude)';
+    }
+
+    async value( optionValue: string, ctxt: ListOfRolesProviderContext ): Promise<ISelectionProviderValues> {
+        
+        const basicFilterQuery = new BasicFilterDto(1, 0);
+        basicFilterQuery.filters = {
+            name: { $eq: optionValue }
+        };
+
+        const roles = await this.roleMetadataService.find(basicFilterQuery);
+
+        if (!roles.records || roles.records.length === 0) {
+            throw new BadRequestException(
+                `Invalid role name: ${optionValue}`
+            );
+        }
+        
+        const role = roles.records[0];
+
+        return {
+            label: role.name,
+            value: role.name
+        };
+    }
+
+    async values( query: string, ctxt: ListOfRolesProviderContext ): Promise<readonly ISelectionProviderValues[]> {
+
+        const basicFilterQuery = new BasicFilterDto(DEFAULT_LIMIT, 0);
+        basicFilterQuery.filters = ctxt.filters || {};
+
+        const roles = await this.roleMetadataService.find(basicFilterQuery);
+
+        return roles.records.map(role => ({
+            label: role.name,
+            value: role.name
+        }));
+    }
+}

package/src/services/user.service.ts

@@ -18,6 +18,7 @@ import { iamConfig } from 'src/config/iam.config';
 import { ERROR_MESSAGES } from 'src/constants/error-messages';
 import { UserRepository } from 'src/repository/user.repository';
 import { RoleMetadataRepository } from 'src/repository/role-metadata.repository';
+import { HashingService } from './hashing.service';
 
 @Injectable()
 export class UserService extends CRUDService<User> {
@@ -29,6 +30,8 @@ export class UserService extends CRUDService<User> {
     readonly fileService: FileService,
     readonly discoveryService: DiscoveryService,
     readonly crudHelperService: CrudHelperService,
+    readonly hashingService: HashingService,
+    
     @InjectEntityManager()
     readonly entityManager: EntityManager,
     // @InjectRepository(User, 'default')
@@ -283,4 +286,20 @@ export class UserService extends CRUDService<User> {
     }
   }
 
+  async hashPassword(password: string): Promise<{
+    password: string;
+    passwordScheme: string;
+    passwordSchemeVersion: number;
+  }> {
+    const hashedPassword = await this.hashingService.hash(password);
+  
+    return {
+      password: hashedPassword,
+      passwordScheme: this.hashingService.name(),
+      passwordSchemeVersion: this.hashingService.currentVersion(),
+    };
+  }
+  
+
 }
+