@solidxai/core 0.1.10-beta.15 → 0.1.10-beta.21

package/src/factories/whatsapp.factory.ts

@@ -1,42 +1,43 @@
-import { Inject, Injectable, Logger } from "@nestjs/common";
-import { ConfigType } from "@nestjs/config";
+import { Injectable, Logger } from "@nestjs/common";
 import { ModuleRef } from "@nestjs/core";
 import { SolidRegistry } from "src/helpers/solid-registry";
 import { IWhatsAppTransport } from "src/interfaces";
 import { SettingService } from "src/services/setting.service";
 import type { SolidCoreSetting } from "src/services/settings/default-settings-provider.service";
 
-function norm(s?: string) {
-    return s?.trim().toLowerCase();
-}
-
-// This factory will be use to return a mail service instance, using the configured environment variables
 @Injectable()
 export class WhatsAppFactory {
-    private readonly logger = new Logger(this.constructor.name);
-    constructor(
-        private readonly moduleRef: ModuleRef, // Use the module ref to dynamically resolve the mail service
-        private readonly solidRegistry: SolidRegistry,
-        private readonly settingService: SettingService,
-    ) { }
-
-    getWhatsappService(name: string = null): IWhatsAppTransport {
-        // This is the default provider
-        const whatsappServiceName = name || this.settingService.getConfigValue<SolidCoreSetting>("whatsappProvider");
-        if (!whatsappServiceName) {
-            throw new Error("Unable to resolve whatsapp provider")
-        }
-        const whatsappProviders = this.solidRegistry.getWhatsappProviders();
-
-        // Return the instance which matches the whatsappServiceName
-        if (!whatsappProviders.length) {
-            // throw new Error("No mail providers are registered.");
-            this.logger.error("No whatsapp providers are registered.");
-        }
-
-        const whatsappServiceProvider = whatsappProviders.find(provider => provider.name === whatsappServiceName);
-
-        return whatsappServiceProvider.instance as IWhatsAppTransport;
+  private readonly logger = new Logger(WhatsAppFactory.name);
+
+  constructor(
+    private readonly moduleRef: ModuleRef,
+    private readonly solidRegistry: SolidRegistry,
+    private readonly settingService: SettingService,
+  ) {}
+
+  getWhatsappService(name?: string): IWhatsAppTransport {
+    const providerKey =
+      name ||
+      this.settingService.getConfigValue<SolidCoreSetting>("whatsappProvider");
+
+    if (!providerKey) {
+      throw new Error("Unable to resolve whatsapp provider");
+    }
+
+    const whatsappProviders = this.solidRegistry.getWhatsappProviders();
+
+    if (!whatsappProviders.length) {
+      throw new Error("No whatsapp providers are registered.");
+    }
+
+    const whatsappServiceProvider = whatsappProviders.find((provider) =>
+      provider.name?.toLowerCase().includes(providerKey.toLowerCase()),
+    );
+
+    if (!whatsappServiceProvider) {
+      throw new Error(`WhatsApp provider '${providerKey}' not found`);
     }
 
-}
+    return whatsappServiceProvider.instance as IWhatsAppTransport;
+  }
+}

package/src/helpers/field-crud-managers/field-quality-check-fixes.md

@@ -0,0 +1,178 @@
+# Field Quality Checks And Fixes
+
+This checklist tracks backend issues and logical enhancements for each field type in `solid-core-module`.
+
+Use it for backend concerns only:
+
+- CRUD validation
+- transformation and normalization
+- persistence behavior
+- relation semantics
+- field-level correctness and consistency
+
+Frontend widget and rendering concerns belong in `solid-core-ui`.
+
+## `shortText`
+
+- [ ] Resolve the `length` versus `max` contract for `shortText` and document one clear meaning for each attribute.
+- [ ] Decide whether backend validation should also enforce `min`, so `shortText` constraints remain consistent even outside generated form flows.
+- [ ] Return the configured regex mismatch message when `regexPatternNotMatchingErrorMsg` is present instead of always using a generic regex error.
+- [ ] Clarify and implement the expected behavior for `defaultValue` when a create payload omits a `shortText` field.
+- [ ] Decide whether `shortText` should support optional normalization such as trimming or whitespace collapsing, and keep that decision consistent across comparable text field types.
+- [ ] Review whether uniqueness should receive any pre-save validation support at the CRUD layer or continue to rely entirely on persistence-layer constraints.
+- [ ] Add targeted coverage for partial update behavior, empty string versus null handling, regex validation, and max-length enforcement.
+- [ ] Review whether the text-oriented managers share enough behavior to justify a common validation utility or base manager without weakening field-specific semantics.
+
+## `longText`
+
+- [ ] Decide whether backend validation should also enforce `min` and `max`, so `longText` constraints remain consistent outside generated form flows.
+- [ ] Return the configured regex mismatch message when `regexPatternNotMatchingErrorMsg` is present instead of always using a generic regex error.
+- [ ] Clarify and implement the expected behavior for `defaultValue` when a create payload omits a `longText` field.
+- [ ] Decide whether `longText` should support optional normalization such as trimming trailing whitespace while preserving intentional line breaks.
+- [ ] Review whether uniqueness should receive any pre-save validation support at the CRUD layer or continue to rely entirely on persistence-layer constraints.
+- [ ] Add targeted coverage for multiline content, regex validation, partial updates, and empty string versus null handling.
+- [ ] Review whether the text-oriented managers share enough behavior to justify a common validation utility or base manager without weakening field-specific semantics.
+
+## `richText`
+
+- [ ] Decide whether backend validation should also enforce `min` and `max`, so `richText` constraints remain consistent outside generated form flows.
+- [ ] Return the configured regex mismatch message when `regexPatternNotMatchingErrorMsg` is present instead of always using a generic regex error.
+- [ ] Clarify and implement the expected behavior for `defaultValue` when a create payload omits a `richText` field.
+- [ ] Decide whether `richText` should support optional normalization or sanitization at save time, and define that behavior explicitly.
+- [ ] Review whether uniqueness should receive any pre-save validation support at the CRUD layer or continue to rely entirely on persistence-layer constraints.
+- [ ] Add targeted coverage for rich HTML-like content, regex validation, partial updates, and empty string versus null handling.
+- [ ] Review whether the text-oriented managers share enough behavior to justify a common validation utility or base manager without weakening field-specific semantics.
+
+## `json`
+
+- [ ] Clarify and implement the expected behavior for `defaultValue` when a create payload omits a `json` field.
+- [ ] Decide whether backend validation should accept only stringified JSON or also handle already-parsed object and array payloads more explicitly.
+- [ ] Review whether the current JSON validation error should distinguish between invalid JSON syntax and unsupported runtime value shapes.
+- [ ] Decide whether normalization or canonical stringification should happen before persistence for comparable JSON values.
+- [ ] Review whether uniqueness should receive any pre-save validation support at the CRUD layer or continue to rely entirely on persistence-layer constraints.
+- [ ] Add targeted coverage for object payloads, array payloads, stringified JSON payloads, invalid JSON, partial updates, and empty string versus null handling.
+
+## `int`
+
+- [ ] Fix the current min/max activation rule, because backend validation only applies numeric bounds when the configured value is greater than `0`, which skips valid `0` and negative thresholds.
+- [ ] Clarify and implement the expected behavior for `defaultValue` when a create payload omits an `int` field.
+- [ ] Decide whether the CRUD layer should normalize numeric strings into integers more explicitly before validation and persistence.
+- [ ] Review whether integer fields should reject decimal-shaped inputs more clearly when values arrive from metadata-driven clients as strings.
+- [ ] Review whether uniqueness should receive any pre-save validation support at the CRUD layer or continue to rely entirely on persistence-layer constraints.
+- [ ] Add targeted coverage for `0`, negative values, numeric strings, invalid decimal-like input, min/max bounds, and partial update behavior.
+
+
+## `bigint`
+
+- [ ] Clarify the authored support surface for `bigint`, because the CRUD manager contains numeric bound logic while the authored field surface does not currently present `min` and `max` in the same way as `int` and `decimal`.
+- [ ] Fix or clarify the current numeric-bound activation rule if bigint bounds are intended to be supported, since the logic only applies bounds when the configured value is greater than `0`.
+- [ ] Clarify and implement the expected behavior for `defaultValue` when a create payload omits a `bigint` field.
+- [ ] Decide what the canonical runtime contract should be for bigint inputs: native `bigint`, numeric strings, or finite JavaScript numbers.
+- [ ] Review whether accepting finite JavaScript numbers for bigint validation is sufficient when exact large-integer fidelity matters.
+- [ ] Review whether uniqueness should receive any pre-save validation support at the CRUD layer or continue to rely entirely on persistence-layer constraints.
+- [ ] Add targeted coverage for numeric strings, very large values, invalid numeric input, bound handling, null handling, and partial update behavior.
+
+
+## `decimal`
+
+- [ ] Fix the current min/max activation rule, because backend validation only applies numeric bounds when the configured value is greater than `0`, which skips valid `0` and negative thresholds.
+- [ ] Clarify and implement the expected behavior for `defaultValue` when a create payload omits a `decimal` field.
+- [ ] Decide whether the CRUD layer should normalize numeric strings into decimal numbers more explicitly before validation and persistence.
+- [ ] Review whether decimal fields need an explicit precision-and-scale contract instead of relying entirely on the persistence-layer `ormType`.
+- [ ] Review whether uniqueness should receive any pre-save validation support at the CRUD layer or continue to rely entirely on persistence-layer constraints.
+- [ ] Add targeted coverage for `0`, negative values, fractional values, numeric strings, invalid numeric input, min/max bounds, and partial update behavior.
+
+
+## `boolean`
+
+- [ ] Clarify and implement the expected behavior for `defaultValue` when a create payload omits a `boolean` field.
+- [ ] Decide whether boolean CRUD validation should accept only runtime booleans or also normalize `"true"` and `"false"` string payloads when they arrive from metadata-driven clients.
+- [ ] Review whether the required validation path should distinguish more clearly between an omitted value and an explicit `false` value, especially for partial updates.
+- [ ] Review whether uniqueness should receive any pre-save validation support at the CRUD layer or continue to rely entirely on persistence-layer constraints.
+- [ ] Add targeted coverage for `true`, `false`, null, empty string, string booleans, and partial update behavior.
+
+## `date`
+
+- [ ] Clarify and implement the expected behavior for `defaultValue` when a create payload omits a `date` field.
+- [ ] Review whether the CRUD layer should accept only runtime `Date` objects or also normalize common serialized date inputs more explicitly before validation.
+- [ ] Decide whether `date` and `datetime` should continue to share the same backend validation path or receive more distinct normalization and validation behavior.
+- [ ] Review whether uniqueness should receive any pre-save validation support at the CRUD layer or continue to rely entirely on persistence-layer constraints.
+- [ ] Add targeted coverage for `Date` objects, serialized date strings, null handling, invalid date inputs, and partial update behavior.
+
+## `datetime`
+
+- [ ] Clarify and implement the expected behavior for `defaultValue` when a create payload omits a `datetime` field.
+- [ ] Review whether the CRUD layer should accept only runtime `Date` objects or also normalize common serialized datetime inputs more explicitly before validation.
+- [ ] Decide whether `date` and `datetime` should continue to share the same backend validation path or receive more distinct normalization and validation behavior.
+- [ ] Review whether timezone normalization rules should be documented and enforced more explicitly at save time.
+- [ ] Review whether uniqueness should receive any pre-save validation support at the CRUD layer or continue to rely entirely on persistence-layer constraints.
+- [ ] Add targeted coverage for `Date` objects, serialized datetime strings, null handling, timezone-sensitive values, invalid datetime inputs, and partial update behavior.
+
+## `time`
+
+- [ ] Add an explicit CRUD-manager path for `SolidFieldType.time`, since the field currently has core UI support but is not routed through a dedicated backend field manager.
+- [ ] Clarify and implement the expected behavior for `defaultValue` when a create payload omits a `time` field.
+- [ ] Decide what canonical persisted shape `time` should use: pure time string, database-native time value, or a normalized timestamp-derived representation.
+- [ ] Review whether the CRUD layer should normalize common time inputs such as `HH:mm:ss`, ISO timestamps, and UI-submitted values more explicitly before validation and persistence.
+- [ ] Review whether uniqueness should receive any pre-save validation support at the CRUD layer or continue to rely entirely on persistence-layer constraints.
+- [ ] Add targeted coverage for `HH:mm:ss` inputs, ISO-style inputs, invalid time values, null handling, and partial update behavior.
+
+## `email`
+
+- [ ] Decide whether backend validation should also enforce `min`, so email constraints remain consistent outside generated form flows.
+- [ ] Return the configured regex mismatch message when `regexPatternNotMatchingErrorMsg` is present instead of always using a generic regex error.
+- [ ] Clarify and implement the expected behavior for `defaultValue` when a create payload omits an `email` field.
+- [ ] Decide whether email values should support optional normalization such as trimming and lowercasing before persistence.
+- [ ] Review whether uniqueness should receive any pre-save validation support at the CRUD layer or continue to rely entirely on persistence-layer constraints.
+- [ ] Add targeted coverage for max-length enforcement, regex overrides, invalid email formats, null handling, and partial update behavior.
+
+## `password`
+
+- [ ] Return the configured regex mismatch message when `regexPatternNotMatchingErrorMsg` is present instead of always using a generic password-regex error.
+- [ ] Review whether password validation should produce clearer error messages for min, max, regex, and confirm-password mismatch failures.
+- [ ] Clarify and implement the expected behavior for `defaultValue` on password fields, including whether it should be ignored entirely for secure create flows.
+- [ ] Review whether password hashing and password-update flows should share a more explicit single contract across create and update operations.
+- [ ] Decide whether password normalization should include trimming or whether exact raw user input should always be preserved before hashing.
+- [ ] Add targeted coverage for create-required behavior, update-optional behavior, confirm-password mismatch, hashing behavior, regex fallback behavior, and partial update behavior.
+
+## `selectionStatic`
+
+- [ ] Clarify and implement the expected behavior for `defaultValue` when a create payload omits a `selectionStatic` field, especially for multi-select fields.
+- [ ] Decide whether the CRUD layer should normalize single-select and multi-select payloads into one consistent stored shape before persistence.
+- [ ] Review whether the current `selectionStaticValues` parsing should validate malformed `value:label` entries more explicitly instead of assuming a valid authored format.
+- [ ] Add clearer error messaging when the submitted value has the wrong type versus when it is simply not part of the authored option set.
+- [ ] Review whether numeric selection values need more explicit normalization, especially when values can arrive as strings from metadata-driven clients.
+- [ ] Add targeted coverage for single-select string values, single-select numeric values, JSON-stringified multi-select arrays, invalid option tokens, malformed arrays, and partial update behavior.
+
+## `selectionDynamic`
+
+- [ ] Clarify and implement the expected behavior for `defaultValue` when a create payload omits a `selectionDynamic` field, especially for multi-select fields.
+- [ ] Review whether the CRUD layer should normalize single-select and multi-select payloads into one consistent stored shape before persistence.
+- [ ] Add clearer error messaging when the submitted value has the wrong type, when the provider rejects the value, and when the provider itself cannot be resolved.
+- [ ] Review whether numeric selection values need more explicit normalization, especially when values can arrive as strings from metadata-driven clients.
+- [ ] Clarify how `validateOnSave` in `selectionDynamicProviderCtxt` should be treated as part of the supported field contract and whether more provider-context keys should be validated.
+- [ ] Add targeted coverage for provider-backed single-select values, JSON-stringified multi-select arrays, invalid provider names, `validateOnSave: false`, invalid option values, and partial update behavior.
+
+## `many-to-one`
+
+- [ ] Review pending.
+
+## `one-to-many`
+
+- [ ] Review pending.
+
+## `many-to-many`
+
+- [ ] Review pending.
+
+## `mediaSingle`
+
+- [ ] Review pending.
+
+## `mediaMultiple`
+
+- [ ] Review pending.
+
+## `computed`
+
+- [ ] Review pending.

package/src/index.ts

@@ -29,6 +29,7 @@ export * from './decorators/settings-provider.decorator'
 export * from './decorators/extension-user-creation-provider.decorator'
 
 export * from './dtos/post-chatter-message.dto'
+export * from './dtos/update-chatter-note-message.dto'
 export * from './dtos/security-rule-config.dto'
 export * from './dtos/basic-filters.dto'
 export * from './dtos/solid-request-context.dto'
@@ -322,6 +323,7 @@ export * from './services/solid-introspect.service'
 export * from './services/user.service'
 export * from './services/view-metadata.service'
 export * from './services/whatsapp/Msg91WhatsappService' //rename
+export * from './services/whatsapp/GupshupOtpWhatsappService'
 export * from './services/setting.service'
 export * from './services/encryption.service'
 export * from './services/info.service'

package/src/interfaces.ts

@@ -42,6 +42,7 @@ export interface ValidationError {
 export interface MediaStorageProvider<T> {
   store(files: Express.Multer.File[], entity: T, mediaFieldMetadata: FieldMetadata): Promise<Media[]>;
   delete(entity: T, mediaFieldMetadata: FieldMetadata): Promise<void>;
+  deleteByMediaRecord(media: Media): Promise<void>;
   retrieve(entity: T, mediaFieldMetadata: FieldMetadata): Promise<Media[]>;
   storeStreams(streamPairs: [Readable, string][], entity: T, mediaFieldMetadata: FieldMetadata): Promise<Media[]>;
   // delete(file: string): Promise<void>;
@@ -448,4 +449,3 @@ export interface AuditQueuePayload {
     updatedColumnNames?: string[];
     userId?: number | null;
 }
-

package/src/listeners/user-registration.listener.ts

@@ -1,14 +1,57 @@
-
 import { User } from "../entities/user.entity";
 import { OnEvent } from "@nestjs/event-emitter";
 import { Injectable, Logger } from "@nestjs/common";
 import { EventDetails, EventType } from "../interfaces";
+import { WhatsAppFactory } from "src/factories/whatsapp.factory";
 
 @Injectable()
 export class UserRegistrationListener {
-    private logger = new Logger(UserRegistrationListener.name);
-    @OnEvent(EventType.USER_REGISTERED)
-    handleUserRegistration(event: EventDetails<User>) {
-        this.logger.log(`User registered with details: ${JSON.stringify(event.payload)}`);
+  private readonly logger = new Logger(UserRegistrationListener.name);
+
+  constructor(private readonly whatsAppFactory: WhatsAppFactory) {}
+
+  @OnEvent(EventType.USER_REGISTERED)
+  async handleUserRegistration(event: EventDetails<User>) {
+    this.logger.log(`User registered with details: ${JSON.stringify(event.payload)}`);
+
+    const notifyTo = process.env.WHATSAPP_EVENT_NOTIFY_TO;
+    if (!notifyTo) {
+      this.logger.debug("WHATSAPP_EVENT_NOTIFY_TO not set. Skipping registration WhatsApp notification.");
+      return;
+    }
+
+    try {
+      const whatsappService = this.whatsAppFactory.getWhatsappService();
+      const username = event.payload?.username || "User";
+      const userId = event.payload?.id || "N/A";
+
+      await whatsappService.sendWhatsAppMessage(
+        notifyTo,
+        "registration_event",
+        {
+          payload: {
+            channel: "whatsapp",
+            source: process.env.COMMON_GUPSHUP_WHATSAPP_SOURCE,
+            destination: notifyTo,
+            "src.name": process.env.COMMON_GUPSHUP_APP_NAME || "solidx",
+            message: {
+              type: "text",
+              text: `New user registered: ${username} (id: ${userId})`,
+            },
+          },
+        },
+      );
+
+      this.logger.log(`Sent registration WhatsApp notification to ${notifyTo}`);
+    } catch (error: any) {
+      const status = error?.response?.status;
+      const responseData = error?.response?.data;
+      const errorMessage = error?.message;
+      const stack = error?.stack;
+
+      this.logger.error(
+        `Failed to send registration WhatsApp notification to ${notifyTo}. status=${status ?? "unknown"}, response=${typeof responseData === "object" ? JSON.stringify(responseData) : responseData}, message=${errorMessage}, stack=${stack}`,
+      );
     }
-}
+  }
+}

package/src/seeders/module-test-data.service.ts

@@ -19,7 +19,7 @@ import { ModelMetadataService } from 'src/services/model-metadata.service';
 import { RoleMetadataService } from 'src/services/role-metadata.service';
 import { UserService } from 'src/services/user.service';
 import { getMediaStorageProvider } from 'src/services/mediaStorageProviders';
-import { TestingRoleSpec, TestingUserSpec } from 'src/testing/contracts/testing-metadata.types';
+import { TestingDataRecord, TestingRoleSpec, TestingUserSpec } from 'src/testing/contracts/testing-metadata.types';
 
 @Injectable()
 export class ModuleTestDataService {
@@ -51,6 +51,25 @@ export class ModuleTestDataService {
     }
   }
 
+  async removeTestData(modulesToTest?: string[]): Promise<void> {
+    const testDataFiles = this.testDataFiles;
+    const filteredFiles = modulesToTest?.length ? testDataFiles.filter((file) => modulesToTest.includes(file.moduleMetadata?.name)) : testDataFiles;
+
+    if (filteredFiles.length === 0) {
+      this.logger.warn('No modules matched the provided modulesToTest list.');
+      console.log('No modules matched the provided modulesToTest list.');
+      return;
+    }
+
+    for (const overallMetadata of filteredFiles) {
+      const moduleName = overallMetadata?.moduleMetadata?.name ?? 'unknown';
+      this.logger.log(`Removing test data for module: ${moduleName}`);
+      console.log(`Removing test data for module: ${moduleName}`);
+      await this.unlinkTestData(overallMetadata);
+      console.log(`✔ Test data unlink complete for module: ${moduleName}`);
+    }
+  }
+
   async createTestDatasources(): Promise<void> {
     const manifestPath = path.join(process.cwd(), '.solidx-test-manifest');
     if (fs.existsSync(manifestPath)) {
@@ -199,7 +218,7 @@ export class ModuleTestDataService {
 
     const testingRoles: TestingRoleSpec[] = overallMetadata?.testing?.roles ?? [];
     const testingUsers: TestingUserSpec[] = overallMetadata?.testing?.users ?? [];
-    const testingData: Array<{ modelUserKey: string; data: Record<string, any> }> = overallMetadata?.testing?.data ?? [];
+    const testingData: TestingDataRecord[] = overallMetadata?.testing?.data ?? [];
 
     if (testingRoles.length > 0) {
       await this.seedTestRoles(testingRoles);
@@ -290,16 +309,21 @@ export class ModuleTestDataService {
       // Upsert entity, capturing the saved result for post-save steps
       let savedEntity: any;
       const userKeyField = modelDef.userKeyFieldUserKey;
+      const recordUserKeyValue = entry.recUserKeyValue ?? payload[userKeyField];
+      const recordLabel = `${modelUserKey}.${userKeyField}=${recordUserKeyValue}`;
       if (userKeyField && payload[userKeyField] !== undefined) {
         const existing = await entityRepo.findOne({
           where: { [userKeyField]: payload[userKeyField] },
         });
         if (existing) {
+          console.log(`Updating test data record: ${recordLabel}`);
           savedEntity = await entityRepo.save(entityRepo.merge(existing, payload));
         } else {
+          console.log(`Creating test data record: ${recordLabel}`);
           savedEntity = await entityRepo.save(entityRepo.create(payload));
         }
       } else {
+        console.log(`Creating test data record without user key lookup: ${modelUserKey}`);
         savedEntity = await entityRepo.save(entityRepo.create(payload));
       }
 
@@ -313,6 +337,59 @@ export class ModuleTestDataService {
     }
   }
 
+  private async unlinkTestData(overallMetadata: any): Promise<void> {
+    const moduleMetadata: CreateModuleMetadataDto = overallMetadata.moduleMetadata;
+    if (!moduleMetadata) {
+      throw new Error('Module metadata missing from test data payload.');
+    }
+
+    const testingData: TestingDataRecord[] = overallMetadata?.testing?.data ?? [];
+    if (testingData.length === 0) {
+      this.logger.debug(`No test data found for ${moduleMetadata.name}`);
+      return;
+    }
+
+    const modelsByName = new Map<string, CreateModelMetadataDto>(
+      (moduleMetadata.models ?? []).map((m) => [m.singularName, m]),
+    );
+
+    for (const entry of [...testingData].reverse()) {
+      const modelUserKey = entry.modelUserKey;
+      const modelDef = modelsByName.get(modelUserKey);
+      if (!modelDef) {
+        throw new Error(`Test data modelUserKey not found in metadata: ${modelUserKey}`);
+      }
+
+      const userKeyField = modelDef.userKeyFieldUserKey;
+      if (!userKeyField) {
+        throw new Error(`Cannot unlink test data for model ${modelUserKey} because userKeyFieldUserKey is not configured.`);
+      }
+
+      const userKeyValue = entry.data?.[userKeyField];
+      if (userKeyValue === undefined || userKeyValue === null || userKeyValue === '') {
+        throw new Error(
+          `Cannot unlink test data for model ${modelUserKey} because testing.data entry is missing the actual user key field "${userKeyField}" in data.`,
+        );
+      }
+      const recordLabel = `${modelUserKey}.${userKeyField}=${userKeyValue}`;
+
+      const entityRepo = this.resolveRepository(modelUserKey);
+      const existing = typeof entityRepo.findOneByUserKey === 'function'
+        ? await entityRepo.findOneByUserKey(userKeyValue)
+        : await entityRepo.findOne({ where: { [userKeyField]: userKeyValue } });
+
+      if (!existing) {
+        console.log(`Skipping unlink; test data record not found: ${recordLabel}`);
+        this.logger.debug(`Test data record not found for unlink: ${modelUserKey}.${userKeyField}=${userKeyValue}`);
+        continue;
+      }
+
+      console.log(`Deleting test data record: ${recordLabel}`);
+      await entityRepo.remove(existing);
+      this.logger.debug(`Removed test data record: ${modelUserKey}.${userKeyField}=${userKeyValue}`);
+    }
+  }
+
   private async seedTestRoles(roles: TestingRoleSpec[]): Promise<void> {
     const roleService = this.moduleRef.get(RoleMetadataService, { strict: false });
     if (!roleService) {

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

@@ -6191,6 +6191,7 @@
         "ChatterMessageController.postMessage",
         "ChatterMessageController.findMany",
         "ChatterMessageController.markCompleted",
+        "ChatterMessageController.updateCustomNoteMessage",
         "ImportTransactionController.getImportTemplate",
         "ImportTransactionController.getImportInstructions",
         "ImportTransactionController.getImportMappingInfo",