@solidstarters/solid-core 1.2.140 → 1.2.142

package/src/services/computed-fields/entity/noops-entity-computed-field-provider.service.ts

@@ -0,0 +1,22 @@
+import { ComputedFieldMetadata } from "src/helpers/solid-registry";
+import { IEntityPostComputeFieldProvider, IEntityPreComputeFieldProvider } from "src/interfaces";
+
+export class NoopsEntityComputedFieldProviderService implements IEntityPreComputeFieldProvider<any, any>, IEntityPostComputeFieldProvider<any, any> {
+    constructor() { }
+
+    name(): string {
+        return "NoopsEntityComputedFieldProviderService";
+    }
+
+    help(): string {
+        return "This is a no-op computed field provider that does nothing.";
+    }
+
+    async preComputeValue(entity: any, computedFieldMetadata: ComputedFieldMetadata<any>): Promise<void> {
+        // No operation performed
+    }
+
+    async postComputeAndSaveValue(entity: any, computedFieldMetadata: ComputedFieldMetadata<any>): Promise<void> {
+        // No operation performed
+    }
+}

package/src/services/mcp-tool-response-handlers/solid-create-dashboard-mcp-tool-response-handler.service.ts

@@ -1,15 +1,27 @@
 import { Injectable } from "@nestjs/common";
 import { plainToInstance } from "class-transformer";
 import { CreateDashboardDto } from "src/dtos/create-dashboard.dto";
+import { UpdateMenuItemMetadataDto } from "src/dtos/update-menu-item-metadata.dto";
 import { AiInteraction } from "src/entities/ai-interaction.entity";
+import { Dashboard } from "src/entities/dashboard.entity";
 import { IMcpToolResponseHandler } from "../../interfaces";
+import { ActionMetadataService } from "../action-metadata.service";
 import { DashboardService } from "../dashboard.service";
+import { MenuItemMetadataService } from "../menu-item-metadata.service";
+import { ModelMetadataService } from "../model-metadata.service";
+import { ModuleMetadataService } from "../module-metadata.service";
+import { RoleMetadataService } from "../role-metadata.service";
 
 @Injectable()
 export class SolidCreateDashboardMcpToolResponseHandler implements IMcpToolResponseHandler {
 
     constructor(
         private readonly dashboardService: DashboardService,
+        private readonly actionMetadataService: ActionMetadataService,
+        private readonly menuItemMetadataService: MenuItemMetadataService,
+        private readonly moduleMetadataService: ModuleMetadataService,
+        private readonly modelMetadataService: ModelMetadataService,
+        private readonly roleService: RoleMetadataService, // Assuming roleService is a Mongoose model, adjust as necessary
     ) {
     }
 
@@ -17,17 +29,11 @@ export class SolidCreateDashboardMcpToolResponseHandler implements IMcpToolRespo
         const escapedMessage = aiInteraction.message.replace(/\\'/g, "'");
         const aiResponseMessage = JSON.parse(escapedMessage);
 
-        // const aiResponse = JSON.parse(aiInteraction.message);
+        const { dashboardDto, dashboard } = await this.createDashboard(aiResponseMessage);
 
-        //FIXME: Replace \' with ' in the response, since the AI response seems to contain \' which is invalid JSON.
-        // This is a workaround for now, until we find a better solution.
-        // const aiResponseMessageReplaced = aiResponse['message'].replace(/\\'/g, "'");
-
-        const dashboardDto = plainToInstance(CreateDashboardDto, aiResponseMessage);
-        dashboardDto['layoutJson'] = JSON.stringify(dashboardDto['layoutJson']);
+        const { moduleUserKey, actionMetadataEntity } = await this.createActionMetadataEntry(dashboardDto, dashboard);
 
-
-        const dashboard = await this.dashboardService.create(dashboardDto, []);
+        await this.createMenuItemEntry(dashboard, moduleUserKey, actionMetadataEntity);
 
         // TODO: decide on some shape to return hre...
         return {
@@ -36,4 +42,72 @@ export class SolidCreateDashboardMcpToolResponseHandler implements IMcpToolRespo
         }
     }
 
+
+    private async createMenuItemEntry(dashboard: Dashboard, moduleUserKey: string, actionMetadataEntity: any) {
+        const menuData = {
+            displayName: dashboard.displayName || dashboard.name,
+            name: `${moduleUserKey}-${dashboard.name}-dashboard-menu-item`,
+            sequenceNumber: 1,
+            actionUserKey: actionMetadataEntity.name,
+            moduleUserKey: moduleUserKey,
+            parentMenuItemUserKey: '',
+        };
+
+        const adminRole = await this.roleService.findRoleByName('Admin');
+        const specifiedRoles = menuData['roles'];
+
+        // If the developer has specified roles, then resolve them, making sure that admin role is also given.
+        const specifiedRoleObjects = [adminRole];
+        if (specifiedRoles) {
+            for (let i = 0; i < specifiedRoles.length; i++) {
+                const specifiedRole = specifiedRoles[i];
+                const specifiedRoleObject = await this.roleService.findRoleByName(specifiedRole);
+                if (!specifiedRoleObject) {
+                    throw new Error(`Invalid role: (${specifiedRole}) specified against menu with display name ${menuData.displayName}.`);
+                }
+                specifiedRoleObjects.push(specifiedRoleObject);
+            }
+        }
+
+        menuData['roles'] = specifiedRoleObjects;
+        menuData['action'] = await this.actionMetadataService.findOneByUserKey(menuData.actionUserKey);
+        menuData['module'] = await this.moduleMetadataService.findOneByUserKey(menuData.moduleUserKey);
+
+        if (menuData.parentMenuItemUserKey) {
+            menuData['parentMenuItem'] = await this.menuItemMetadataService.findOneByUserKey(menuData.parentMenuItemUserKey);
+        } else {
+            menuData['parentMenuItem'] = null;
+        }
+        await this.menuItemMetadataService.upsert(menuData as unknown as UpdateMenuItemMetadataDto);
+    }
+
+    private async createActionMetadataEntry(dashboardDto: CreateDashboardDto, dashboard: Dashboard) {
+        const moduleUserKey = dashboardDto.moduleUserKey;
+        const actionMetadata = {
+            name: `${dashboard.name}-view`,
+            displayName: dashboard.displayName || dashboard.name,
+            type: 'custom',
+            domain: "{}",
+            context: "{}",
+            customComponent: `/admin/core/${moduleUserKey}/dashboards?dashboardName=${dashboard.name}`,
+            customIsModal: true,
+            serverEndpoint: '',
+            moduleUserKey: moduleUserKey,
+            modelUserKey: '',
+            viewUserKey: `${dashboard.name}-view`,
+        };
+        actionMetadata['module'] = await this.moduleMetadataService.findOneByUserKey(actionMetadata.moduleUserKey);
+        if (actionMetadata.modelUserKey) {
+            actionMetadata['model'] = await this.modelMetadataService.findOneByUserKey(actionMetadata.modelUserKey);
+        }
+        const actionMetadataEntity = await this.actionMetadataService.upsert(actionMetadata);
+        return { moduleUserKey, actionMetadataEntity };
+    }
+
+    private async createDashboard(aiResponseMessage: any) {
+        const dashboardDto = plainToInstance(CreateDashboardDto, aiResponseMessage);
+        dashboardDto['layoutJson'] = JSON.stringify(dashboardDto['layoutJson']);
+        const dashboard = await this.dashboardService.create(dashboardDto, []);
+        return { dashboardDto, dashboard };
+    }
 }

package/src/services/mcp-tool-response-handlers/solid-save-model-layout-mcp-tool-response-handler.service.ts

@@ -0,0 +1,34 @@
+import { Injectable } from "@nestjs/common";
+import { AiInteraction } from "src/entities/ai-interaction.entity";
+import { ViewMetadataRepository } from "src/repository/view-metadata.repository";
+import { IMcpToolResponseHandler } from "../../interfaces";
+
+@Injectable()
+export class SolidCreateModelLayoutMcpToolResponseHandler implements IMcpToolResponseHandler {
+
+    constructor(
+        private readonly viewMetadataRepository: ViewMetadataRepository,
+    ) {
+    }
+
+    async apply(aiInteraction: AiInteraction) {
+        const aiResponse = JSON.parse(aiInteraction.message);
+
+        // Get the data for resolving the view metadata
+        const {name, modelUserKey, moduleUserKey, layout} = aiResponse;
+
+        // Fetch the view metadata for the given model and module and the view name
+        const viewMetadata = await this.viewMetadataRepository.findByNameAndModelNameAndModuleName(name, modelUserKey, moduleUserKey);
+
+        viewMetadata.layout = JSON.stringify(layout);
+        // Save the updated view metadata
+        await this.viewMetadataRepository.save(viewMetadata);
+
+        // TODO: decide on some shape to return hre...
+        return {
+            seedingRequired: false,
+            serverRebooting: false,
+        }
+    }
+
+}

package/src/services/setting.service.ts

@@ -66,7 +66,13 @@ export class SettingService extends CRUDService<Setting> {
       enableDarkMode: true,
       copyright: null,
       enableUsername: true,
-      enabledNotification: true
+      enabledNotification: true,
+      contactSupportEmail : null,
+      contactSupportDisplayName: null,
+      contactSupportIcon: null,
+      authScreenRightBackgroundImage: null,
+      authScreenLeftBackgroundImage: null,
+      authScreenCenterBackgroundImage: null,
     };
 
     const existingSettings = await this.repo.find();
@@ -153,7 +159,13 @@ export class SettingService extends CRUDService<Setting> {
       copyright: null,
       forceChangePasswordOnFirstLogin: true,
       enableUsername: true,
-      enabledNotification: true
+      enabledNotification: true,
+      contactSupportEmail : null,
+      contactSupportDisplayName: null,
+      contactSupportIcon: null,
+      authScreenRightBackgroundImage: null,
+      authScreenLeftBackgroundImage: null,
+      authScreenCenterBackgroundImage: null,
     };
   }
 

package/src/services/user.service.ts

@@ -39,6 +39,28 @@ export class UserService extends CRUDService<User> {
     super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'user', 'solid-core', moduleRef);
   }
 
+  override async delete(id: number, solidRequestContext: any = {}) {
+    // Prevent user from deleting themselves
+    if (solidRequestContext?.activeUser?.sub === id) {
+      throw new BadRequestException('Deleting logged-in user is not allowed');
+    }
+
+    // ✅ Proceed with the default deletion logic
+    return super.delete(id, solidRequestContext);
+  }
+
+  override async deleteMany(ids: number[], solidRequestContext: any = {}): Promise<any> {
+    if (!ids || ids.length === 0) {
+      throw new Error('At least one ID is required for deletion');
+    }
+
+    // ❌ If the active user is trying to delete themselves
+    if (solidRequestContext?.activeUser?.sub && ids.includes(solidRequestContext.activeUser.id)) {
+      throw new BadRequestException('Deleting logged-in user is not allowed');
+    }
+
+    return super.deleteMany(ids, solidRequestContext);
+  }
 
   async findOneByEmail(email: string): Promise<User> {
     return await this.repo.findOne({

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

@@ -20,6 +20,7 @@ import { ViewMetadata } from '../entities/view-metadata.entity';
 import { ActionMetadataService } from './action-metadata.service';
 import { SolidIntrospectService } from './solid-introspect.service';
 import { UserViewMetadataService } from './user-view-metadata.service';
+import { ViewMetadataRepository } from 'src/repository/view-metadata.repository';
 
 @Injectable()
 export class ViewMetadataService extends CRUDService<ViewMetadata> {
@@ -35,8 +36,8 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
     readonly userViewMetadataService: UserViewMetadataService,
     @InjectEntityManager()
     readonly entityManager: EntityManager,
-    @InjectRepository(ViewMetadata, 'default')
-    readonly repo: Repository<ViewMetadata>,
+    // @InjectRepository(ViewMetadata, 'default')
+    readonly repo: ViewMetadataRepository,
     @InjectRepository(FieldMetadata)
     private readonly fieldMetadataRepo: Repository<FieldMetadata>,
     @InjectRepository(ModelMetadata)

package/src/solid-core.module.ts

@@ -255,6 +255,10 @@ import { ViewMetadataSubsciber } from './subscribers/view-metadata.subscriber';
 import { SolidCreateDashboardWidgetMcpToolResponseHandler } from './services/mcp-tool-response-handlers/solid-create-dashboard-widget-mcp-tool-response-handler.service';
 import { SolidCreateModelWithFieldsMcpToolResponseHandler } from './services/mcp-tool-response-handlers/solid-create-model-with-fields-mcp-tool-response-handler.service';
 import { SolidAddFieldMcpToolResponseHandler } from './services/mcp-tool-response-handlers/solid-add-field-mcp-tool-response-handler.service';
+import { ViewMetadataRepository } from './repository/view-metadata.repository';
+import { SolidCreateModelLayoutMcpToolResponseHandler } from './services/mcp-tool-response-handlers/solid-save-model-layout-mcp-tool-response-handler.service';
+import { NoopsEntityComputedFieldProviderService } from './services/computed-fields/entity/noops-entity-computed-field-provider.service';
+import { AlphaNumExternalIdComputationProvider } from './services/computed-fields/entity/alpha-num-external-id-computed-field-provider';
 
 
 @Global()
@@ -534,12 +538,16 @@ import { SolidAddFieldMcpToolResponseHandler } from './services/mcp-tool-respons
     DashboardVariableSubscriber,
     DashboardQuestionSubscriber,
     DashboardQuestionSqlDatasetConfigSubscriber,
+    NoopsEntityComputedFieldProviderService,
     SolidCreateDashboardMcpToolResponseHandler,
     SolidCreateDashboardQuestionMcpToolResponseHandler,
     SolidCreateDashboardQuestionSqlDatasetConfigMcpToolResponseHandler,
     SolidCreateDashboardWidgetMcpToolResponseHandler,
     SolidCreateModelWithFieldsMcpToolResponseHandler,
     SolidAddFieldMcpToolResponseHandler,
+    ViewMetadataRepository,
+    SolidCreateModelLayoutMcpToolResponseHandler,
+    AlphaNumExternalIdComputationProvider,
   ],
   exports: [
     ModuleMetadataService,

package/src/subscribers/computed-entity-field.subscriber.ts

@@ -89,17 +89,19 @@ export class ComputedEntityFieldSubscriber implements EntitySubscriberInterface
     }
 
     private async evaluateComputedField(computedFieldMetadata: ComputedFieldMetadata<any>, entity: any) {
-        const computedValue = await this.getComputedValue(computedFieldMetadata, entity);
-        entity[computedFieldMetadata.fieldName] = computedValue; // Set the computed value on the entity
+        const computedValue = await this.preComputeValue(computedFieldMetadata, entity);
+        if (computedValue) {
+            entity[computedFieldMetadata.fieldName] = computedValue; //TODO: This line here is just for backward compatibility, once the pre compute interface is change to return void, we will get rid of it.
+        }
     }
 
-    private async getComputedValue(computedFieldMetadata: ComputedFieldMetadata<any>, entity: any) {
+    private async preComputeValue(computedFieldMetadata: ComputedFieldMetadata<any>, entity: any) {
         try {
             const provider = this.solidRegistry.getComputedFieldProvider(computedFieldMetadata.computedFieldValueProviderName);
             // Get the instance of the provider and assert it is of type IEntityComputedFieldProvider
             const providerInstance = provider.instance as IEntityPreComputeFieldProvider<any, any, any>; // IEntityComputedFieldProvider
             const computedValue = await providerInstance.preComputeValue(entity, computedFieldMetadata); //FIXME There should some way to check/assert if the provider actually has a postComputeAndSaveValue
-            return computedValue;
+            return computedValue; //TODO: This line here is just for backward compatibility, once the pre compute interface is change to return void, we will get rid of it.
         } catch (error) {
             throw new InternalServerErrorException(`Error evaluating computed field ${computedFieldMetadata.fieldName} for model ${computedFieldMetadata.modelName} for triggered entity ${entity.constructor.name}: ${error.message}`);
         }