@solidstarters/solid-core 1.2.141 → 1.2.142

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/solid-core.module.ts

@@ -257,6 +257,8 @@ import { SolidCreateModelWithFieldsMcpToolResponseHandler } from './services/mcp
 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()
@@ -536,6 +538,7 @@ import { SolidCreateModelLayoutMcpToolResponseHandler } from './services/mcp-too
     DashboardVariableSubscriber,
     DashboardQuestionSubscriber,
     DashboardQuestionSqlDatasetConfigSubscriber,
+    NoopsEntityComputedFieldProviderService,
     SolidCreateDashboardMcpToolResponseHandler,
     SolidCreateDashboardQuestionMcpToolResponseHandler,
     SolidCreateDashboardQuestionSqlDatasetConfigMcpToolResponseHandler,
@@ -544,6 +547,7 @@ import { SolidCreateModelLayoutMcpToolResponseHandler } from './services/mcp-too
     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}`);
         }