@solidxai/core 0.1.11-beta.0 → 0.1.11-beta.2

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

@@ -5244,6 +5244,13 @@
       }
     ]
   },
+  "locales": [
+    {
+      "locale": "en",
+      "displayName": "English",
+      "isDefault": true
+    }
+  ],
   "permissions": [
     "mcp:invoke",
     "agent:invoke",

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

@@ -1,4 +1,4 @@
-import { Injectable } from '@nestjs/common';
+import { Injectable, Logger } from '@nestjs/common';
 import { ModuleRef } from "@nestjs/core";
 import { InjectEntityManager } from '@nestjs/typeorm';
 import { CRUDService } from 'src/services/crud.service';
@@ -10,6 +10,79 @@ import { ActionMetadata } from '../entities/action-metadata.entity';
 
 @Injectable()
 export class ActionMetadataService extends CRUDService<ActionMetadata> {
+  private readonly logger = new Logger(ActionMetadataService.name);
+  private readonly comparableFields = [
+    'name',
+    'displayName',
+    'type',
+    'domain',
+    'context',
+    'customComponent',
+    'customIsModal',
+    'serverEndpoint',
+    'module',
+    'model',
+    'view',
+  ] as const;
+  private readonly relationCompareFields = new Set(['module', 'model', 'view']);
+  private readonly jsonCompareFields = new Set(['domain', 'context']);
+
+  private normalizeJsonFieldValue(value: any): any {
+    if (typeof value === 'string') {
+      const trimmedValue = value.trim();
+      if (
+        (trimmedValue.startsWith('{') && trimmedValue.endsWith('}')) ||
+        (trimmedValue.startsWith('[') && trimmedValue.endsWith(']'))
+      ) {
+        try {
+          return this.normalizeJsonFieldValue(JSON.parse(trimmedValue));
+        } catch {
+          return value;
+        }
+      }
+      return value;
+    }
+
+    if (Array.isArray(value)) {
+      return value.map((item) => this.normalizeJsonFieldValue(item));
+    }
+
+    if (value && typeof value === 'object') {
+      return Object.keys(value)
+        .sort()
+        .reduce((result, key) => {
+          result[key] = this.normalizeJsonFieldValue(value[key]);
+          return result;
+        }, {} as Record<string, any>);
+    }
+
+    return value;
+  }
+
+  private getCanonicalJsonFieldString(value: any): string {
+    return JSON.stringify(this.normalizeJsonFieldValue(value) ?? null);
+  }
+
+  private hasChanges(existingSolidAction: ActionMetadata, updateSolidActionDto: any): boolean {
+    return this.comparableFields.some((key) => {
+      const value = updateSolidActionDto[key];
+      if (typeof value === 'undefined') {
+        return false;
+      }
+
+      if (this.relationCompareFields.has(key)) {
+        const relationValue = value as any;
+        return (existingSolidAction as any)[key]?.id !== relationValue?.id;
+      }
+
+      if (this.jsonCompareFields.has(key)) {
+        return this.getCanonicalJsonFieldString((existingSolidAction as any)[key]) !== this.getCanonicalJsonFieldString(value);
+      }
+
+      return (existingSolidAction as any)[key] !== value;
+    });
+  }
+
   constructor(
     @InjectEntityManager()
     readonly entityManager: EntityManager,
@@ -37,11 +110,23 @@ export class ActionMetadataService extends CRUDService<ActionMetadata> {
     const existingSolidAction = await this.repo.findOne({
       where: {
         name: updateSolidActionDto.name
-      }
+      },
+      relations: {
+        module: true,
+        model: true,
+        view: true,
+      },
     })
 
     // if found
     if (existingSolidAction) {
+      const hasChanges = this.hasChanges(existingSolidAction, updateSolidActionDto);
+
+      if (!hasChanges) {
+        this.logger.debug(`Skipping action upsert for ${updateSolidActionDto.name}; no changes detected.`);
+        return existingSolidAction;
+      }
+
       const updatedSolidActionDto = { ...existingSolidAction, ...updateSolidActionDto };
       return this.repo.save(updatedSolidActionDto);
     }

package/src/services/computed-fields/entity/alpha-num-external-id-computed-field-provider.ts

@@ -45,7 +45,12 @@ export class AlphaNumExternalIdComputationProvider<T extends CommonEntity> imple
       }
     }
 
-    const uniqueCode = await this.generateUniqueExternalId(resolvedPrefix, codeLength, computedFieldMetadata.fieldName, entityName);
+    // Use the originating transaction's EntityManager so the uniqueness check runs on the
+    // active connection. Falls back to the injected manager only when no event context is
+    // available (e.g. direct invocation outside a TypeORM lifecycle event).
+    const manager = eventContext?.manager ?? this.entityManager;
+
+    const uniqueCode = await this.generateUniqueExternalId(manager, resolvedPrefix, codeLength, computedFieldMetadata.fieldName, entityName);
     const finalExternalId = resolvedPrefix ? `${resolvedPrefix}-${uniqueCode}` : uniqueCode;
 
     triggerEntity[computedFieldMetadata.fieldName] = finalExternalId;
@@ -60,8 +65,8 @@ export class AlphaNumExternalIdComputationProvider<T extends CommonEntity> imple
     return result;
   }
 
-  private async isExternalIdUnique(externalId: string, fieldName: string, entityName: string): Promise<boolean> {
-    const count = await this.entityManager.count(entityName as any,
+  private async isExternalIdUnique(manager: EntityManager, externalId: string, fieldName: string, entityName: string): Promise<boolean> {
+    const count = await manager.count(entityName as any,
       {
         where: { [fieldName]: externalId },
       }
@@ -69,7 +74,7 @@ export class AlphaNumExternalIdComputationProvider<T extends CommonEntity> imple
     return count === 0;
   }
 
-  private async generateUniqueExternalId(resolvedPrefix: string, codeLength: number, fieldName: string, entityName: string): Promise<string> {
+  private async generateUniqueExternalId(manager: EntityManager, resolvedPrefix: string, codeLength: number, fieldName: string, entityName: string): Promise<string> {
     const maxAttempts = 10;
 
     for (let attempt = 0; attempt < maxAttempts; attempt++) {
@@ -78,7 +83,7 @@ export class AlphaNumExternalIdComputationProvider<T extends CommonEntity> imple
 
       const fullId = resolvedPrefix ? `${resolvedPrefix}-${newId}` : newId;
 
-      const isUnique = await this.isExternalIdUnique(fullId, fieldName, entityName);
+      const isUnique = await this.isExternalIdUnique(manager, fullId, fieldName, entityName);
 
       if (isUnique) {
         return newId;

package/src/services/locale.service.ts

@@ -1,7 +1,7 @@
-import { Injectable, Logger, OnApplicationBootstrap } from '@nestjs/common';
+import { BadRequestException, Injectable, Logger, OnApplicationBootstrap } from '@nestjs/common';
 import { ModuleRef } from "@nestjs/core";
 import { InjectEntityManager } from '@nestjs/typeorm';
-import { EntityManager } from 'typeorm';
+import { EntityManager, In, IsNull, Not } from 'typeorm';
 
 import { Locale } from 'src/entities/locale.entity';
 import { SolidRegistry } from 'src/helpers/solid-registry';
@@ -31,7 +31,115 @@ export class LocaleService extends CRUDService<Locale> implements OnApplicationB
     // Load the security rules from the database
     this.loadLocales();
   }
-   async loadLocales() {
+
+  private async assertCanSetAsDefault(currentLocaleId?: number) {
+    const defaultLocales = await this.repo.find({
+      where: {
+        isDefault: true,
+      } as any,
+    });
+
+    const conflictingDefaultLocale = defaultLocales.find(
+      (locale) => locale.id !== currentLocaleId
+    );
+
+    if (conflictingDefaultLocale) {
+      throw new BadRequestException(
+        `Locale "${conflictingDefaultLocale.displayName}" is already marked as default. Mark it as non-default first.`
+      );
+    }
+  }
+
+  override async create(createDto: any, files: Express.Multer.File[] = [], solidRequestContext: any = {}): Promise<Locale> {
+    if (createDto?.isDefault === true) {
+      await this.assertCanSetAsDefault();
+    }
+
+    const savedLocale = await super.create(createDto, files, solidRequestContext);
+    await this.loadLocales();
+    return savedLocale;
+  }
+
+  override async insertMany(createDtos: any[], filesArray: Express.Multer.File[][] = [], solidRequestContext: any = {}): Promise<Locale[]> {
+    const defaultLocalesInPayload = (createDtos || []).filter((dto) => dto?.isDefault === true);
+
+    if (defaultLocalesInPayload.length > 1) {
+      throw new BadRequestException(`Only one locale can be marked as default.`);
+    }
+
+    if (defaultLocalesInPayload.length === 1) {
+      await this.assertCanSetAsDefault();
+    }
+
+    const savedLocales = await super.insertMany(createDtos, filesArray, solidRequestContext);
+    await this.loadLocales();
+    return savedLocales;
+  }
+
+  override async update(id: number, updateDto: any, files: Express.Multer.File[] = [], isPartialUpdate: boolean = false, solidRequestContext: any = {}, isUpdate: boolean = false): Promise<Locale> {
+    if (updateDto?.isDefault === true) {
+      await this.assertCanSetAsDefault(id);
+    }
+
+    const savedLocale = await super.update(id, updateDto, files, isPartialUpdate, solidRequestContext, isUpdate);
+    await this.loadLocales();
+    return savedLocale;
+  }
+
+  override async recover(id: number, solidRequestContext: any = {}) {
+    const localeToRecover = await this.repo.findOne({
+      where: {
+        id,
+        deletedAt: Not(IsNull()),
+      } as any,
+      withDeleted: true,
+    });
+
+    if (localeToRecover?.isDefault) {
+      await this.assertCanSetAsDefault(id);
+    }
+
+    const recoveredLocale = await super.recover(id, solidRequestContext);
+    await this.loadLocales();
+    return recoveredLocale;
+  }
+
+  override async recoverMany(ids: number[], solidRequestContext: any = {}) {
+    const localesToRecover = await this.repo.find({
+      where: {
+        id: In(ids),
+        deletedAt: Not(IsNull()),
+      } as any,
+      withDeleted: true,
+    });
+
+    const defaultLocalesToRecover = localesToRecover.filter((locale) => locale.isDefault);
+    if (defaultLocalesToRecover.length > 1) {
+      throw new BadRequestException(`Only one locale can be marked as default.`);
+    }
+
+    if (defaultLocalesToRecover.length === 1) {
+      await this.assertCanSetAsDefault(defaultLocalesToRecover[0].id);
+    }
+
+    const recoveredLocales = await super.recoverMany(ids, solidRequestContext);
+    await this.loadLocales();
+    return recoveredLocales;
+  }
+
+  override async delete(id: number, solidRequestContext: any = {}) {
+    const deletedLocale = await super.delete(id, solidRequestContext);
+    await this.loadLocales();
+    return deletedLocale;
+  }
+
+  override async deleteMany(ids: number[], solidRequestContext: any = {}) {
+    const deletedLocales = await super.deleteMany(ids, solidRequestContext);
+    await this.loadLocales();
+    return deletedLocales;
+  }
+
+  async loadLocales() {
     const locales = await this.repo.find();
     this.logger.debug(`Loaded ${locales.length} locales into registry`);
     this.solidRegistry.registerlocales(locales);

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

@@ -8,12 +8,14 @@ import { ERROR_MESSAGES } from 'src/constants/error-messages';
 import { PermissionMetadataRepository } from 'src/repository/permission-metadata.repository';
 import { RoleMetadataRepository } from 'src/repository/role-metadata.repository';
 import { CreateRoleMetadataDto } from '../dtos/create-role-metadata.dto';
+import { ModuleMetadata } from '../entities/module-metadata.entity';
 import { PermissionMetadata } from '../entities/permission-metadata.entity';
 import { RoleMetadata } from '../entities/role-metadata.entity';
 
 @Injectable()
 export class RoleMetadataService extends CRUDService<RoleMetadata> {
   private readonly logger = new Logger(RoleMetadataService.name);
+  private readonly permissionAssignmentBatchSize = 500;
 
   constructor(
     @InjectEntityManager()
@@ -64,13 +66,16 @@ export class RoleMetadataService extends CRUDService<RoleMetadata> {
     for (let id = 0; id < roles.length; id++) {
       try {
         const roleObj = roles[id];
+        const module = await this.resolveRoleModule(roleObj);
         // this.logger.log(`Resolving role: ${JSON.stringify(roleObj)}`);
 
         const existingRole = await this.repo.findOne({
           where: {
             name: roleObj.name,
           },
-          relations: {},
+          relations: {
+            module: true,
+          },
         });
 
         // Create only if not existing already.
@@ -86,9 +91,13 @@ export class RoleMetadataService extends CRUDService<RoleMetadata> {
           }
 
           // const role = this.repo.create({ ...roleObj, permissions });
-          const role = this.repo.create({ ...roleObj });
+          const role = this.repo.create({ ...roleObj, ...(module ? { module } : {}) });
           await this.repo.save(role);
         } else {
+          if (module && existingRole.module?.id !== module.id) {
+            existingRole.module = module;
+            await this.repo.save(existingRole);
+          }
           /*
           this.logger.debug(`Role ${roleObj.name} already exists`);
           const existingPermissions = existingRole.permissions.map(permission => permission.name);
@@ -111,6 +120,22 @@ export class RoleMetadataService extends CRUDService<RoleMetadata> {
     }
   }
 
+  private async resolveRoleModule(roleObj: CreateRoleMetadataDto): Promise<ModuleMetadata | null> {
+    if (roleObj.moduleId) {
+      return await this.entityManager.getRepository(ModuleMetadata).findOne({
+        where: { id: roleObj.moduleId },
+      });
+    }
+
+    if (roleObj.moduleUserKey) {
+      return await this.entityManager.getRepository(ModuleMetadata).findOne({
+        where: { name: roleObj.moduleUserKey },
+      });
+    }
+
+    return null;
+  }
+
   async addAllPermissionsToRole(roleName: string): Promise<RoleMetadata> {
     return await this._addPermissionsToRole(roleName, null);
   }
@@ -126,66 +151,47 @@ export class RoleMetadataService extends CRUDService<RoleMetadata> {
   private async _addPermissionsToRole(roleName: string, permissionNames: string[]): Promise<RoleMetadata> {
     const role = await this.repo.findOne({
       where: { name: roleName },
-      relations: {
-        permissions: true
+      select: {
+        id: true,
+        name: true,
       }
     });
     if (!role) {
       throw new Error(`Role '${roleName}' not found.`);
     }
 
-    // this.logger.log(`Found role ${roleName}`);
+    const joinInfo = this.getRolePermissionJoinInfo();
+    const targetPermissions = await this.loadTargetPermissions(permissionNames);
 
-    // The new set of permissions which are to be added to this role.
-    let newPermissions: PermissionMetadata[];
+    if (!permissionNames || permissionNames.length === 0) {
+      await this.entityManager
+        .createQueryBuilder()
+        .delete()
+        .from(joinInfo.tableName)
+        .where(`${joinInfo.roleIdColumn} = :roleId`, { roleId: role.id })
+        .execute();
 
-    // Load all the specified permissions in the system. 
-    if (permissionNames && permissionNames.length != 0) {
-      // this.logger.log(`Loading specified permissions.`);
-
-      newPermissions = await this.permissionRepository.find({ where: { name: In(permissionNames) } });
-      if (newPermissions.length !== permissionNames.length) {
-        throw new Error(`One or more permissions not found.`);
-      }
+      await this.insertRolePermissionMappings(role.id, targetPermissions.map((permission) => permission.id), joinInfo);
     }
     else {
-      // this.logger.log(`Loading all permissions in system.`);
-
-      // Load all permissions in the system. 
-      // TODO: Do we want to convert this to a paginated query to avoid having to load a very large permissions table into memory?
-      newPermissions = await this.permissionRepository.find();
-      if (newPermissions.length == 0) {
-        throw new Error(`No permissions configured in the system. Did you forget to run the PermissionSeederService?`);
-      }
-    }
-
-    // this.logger.log(`Adding ${newPermissions.length} permissions to role ${roleName}.`);
-
-    // if there are already permissions assigned. 
-    if (role.permissions && role.permissions.length > 0) {
-      for (let i = 0; i < newPermissions.length; i++) {
-        const newPermission = newPermissions[i];
-        let newPermissionFound = true;
-        for (let j = 0; j < role.permissions.length; j++) {
-          const existingPermission = role.permissions[j];
-          if (existingPermission.name === newPermission.name) {
-            newPermissionFound = false;
-            break;
-          }
-        }
-
-        if (newPermissionFound) {
-          role.permissions.push(newPermission);
-        }
+      const existingRows = await this.entityManager
+        .createQueryBuilder()
+        .select(joinInfo.permissionIdColumn, 'permissionId')
+        .from(joinInfo.tableName, 'role_permission')
+        .where(`${joinInfo.roleIdColumn} = :roleId`, { roleId: role.id })
+        .getRawMany();
+
+      const existingPermissionIds = new Set(existingRows.map((row) => Number(row.permissionId)));
+      const missingPermissionIds = targetPermissions
+        .map((permission) => permission.id)
+        .filter((permissionId) => !existingPermissionIds.has(permissionId));
+
+      if (missingPermissionIds.length > 0) {
+        await this.insertRolePermissionMappings(role.id, missingPermissionIds, joinInfo);
       }
-
-    }
-    // else we create a new permissions set. 
-    else {
-      role.permissions = newPermissions;
     }
 
-    return await this.repo.save(role);
+    return await this.findRoleByName(roleName);
   }
 
   async removePermissionsFromRole(roleName: string, permissionNames: string[]): Promise<RoleMetadata> {
@@ -220,5 +226,62 @@ export class RoleMetadataService extends CRUDService<RoleMetadata> {
     return existingPermission;
   }
 
+  private async loadTargetPermissions(permissionNames: string[] | null): Promise<PermissionMetadata[]> {
+    if (permissionNames && permissionNames.length !== 0) {
+      const uniquePermissionNames = [...new Set(permissionNames)];
+      const permissions = await this.permissionRepository.find({ where: { name: In(uniquePermissionNames) } });
+      if (permissions.length !== uniquePermissionNames.length) {
+        throw new Error(`One or more permissions not found.`);
+      }
+      return permissions;
+    }
+
+    const permissions = await this.permissionRepository.find();
+    if (permissions.length === 0) {
+      throw new Error(`No permissions configured in the system. Did you forget to run the PermissionSeederService?`);
+    }
+    return permissions;
+  }
+
+  private getRolePermissionJoinInfo(): { tableName: string; roleIdColumn: string; permissionIdColumn: string } {
+    const relation = this.repo.metadata.relations.find((candidate) => candidate.propertyName === 'permissions');
+    if (!relation?.junctionEntityMetadata) {
+      throw new Error('Role-permission join table metadata not found.');
+    }
+
+    const roleIdColumn = relation.joinColumns[0]?.databaseName;
+    const permissionIdColumn = relation.inverseJoinColumns[0]?.databaseName;
+    if (!roleIdColumn || !permissionIdColumn) {
+      throw new Error('Role-permission join table column metadata not found.');
+    }
+
+    return {
+      tableName: relation.junctionEntityMetadata.tableName,
+      roleIdColumn,
+      permissionIdColumn,
+    };
+  }
+
+  private async insertRolePermissionMappings(
+    roleId: number,
+    permissionIds: number[],
+    joinInfo: { tableName: string; roleIdColumn: string; permissionIdColumn: string },
+  ): Promise<void> {
+    for (let index = 0; index < permissionIds.length; index += this.permissionAssignmentBatchSize) {
+      const batch = permissionIds.slice(index, index + this.permissionAssignmentBatchSize);
+      await this.entityManager
+        .createQueryBuilder()
+        .insert()
+        .into(joinInfo.tableName)
+        .values(
+          batch.map((permissionId) => ({
+            [joinInfo.roleIdColumn]: roleId,
+            [joinInfo.permissionIdColumn]: permissionId,
+          })),
+        )
+        .execute();
+    }
+  }
+
 
 }

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

@@ -21,6 +21,74 @@ import { MenuItemMetadata } from 'src/entities/menu-item-metadata.entity';
 
 @Injectable()
 export class ViewMetadataService extends CRUDService<ViewMetadata> {
+  private readonly comparableFields = [
+    'name',
+    'displayName',
+    'type',
+    'context',
+    'layout',
+    'module',
+    'model',
+  ] as const;
+  private readonly relationCompareFields = new Set(['module', 'model']);
+  private readonly jsonCompareFields = new Set(['layout', 'context']);
+
+  private normalizeJsonFieldValue(value: any): any {
+    if (typeof value === 'string') {
+      const trimmedValue = value.trim();
+      if (
+        (trimmedValue.startsWith('{') && trimmedValue.endsWith('}')) ||
+        (trimmedValue.startsWith('[') && trimmedValue.endsWith(']'))
+      ) {
+        try {
+          return this.normalizeJsonFieldValue(JSON.parse(trimmedValue));
+        } catch {
+          return value;
+        }
+      }
+      return value;
+    }
+
+    if (Array.isArray(value)) {
+      return value.map((item) => this.normalizeJsonFieldValue(item));
+    }
+
+    if (value && typeof value === 'object') {
+      return Object.keys(value)
+        .sort()
+        .reduce((result, key) => {
+          result[key] = this.normalizeJsonFieldValue(value[key]);
+          return result;
+        }, {} as Record<string, any>);
+    }
+
+    return value;
+  }
+
+  private getCanonicalJsonFieldString(value: any): string {
+    return JSON.stringify(this.normalizeJsonFieldValue(value) ?? null);
+  }
+
+  private hasChanges(existingSolidView: ViewMetadata, updateSolidViewDto: UpdateViewMetadataDto): boolean {
+    return this.comparableFields.some((key) => {
+      const value = (updateSolidViewDto as any)[key];
+      if (typeof value === 'undefined') {
+        return false;
+      }
+
+      if (this.relationCompareFields.has(key)) {
+        const relationValue = value as any;
+        return (existingSolidView as any)[key]?.id !== relationValue?.id;
+      }
+
+      if (this.jsonCompareFields.has(key)) {
+        return this.getCanonicalJsonFieldString((existingSolidView as any)[key]) !== this.getCanonicalJsonFieldString(value);
+      }
+
+      return (existingSolidView as any)[key] !== value;
+    });
+  }
+
   constructor(
     readonly actionMetadataService: ActionMetadataService,
     readonly menuItemMetadataService: MenuItemMetadataService,
@@ -83,15 +151,11 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
       return { records: [], defaultEntityLocaleId: null };
     }
 
-    const defaultLocale = await this.entityManager.getRepository(Locale).findOne({ where: { isDefault: true } });
-
-    let defaultEntityLocaleId: string;
-    if (entityRecord.localeName === defaultLocale?.locale) {
-      defaultEntityLocaleId = entityRecord.id;
-      this.logger.debug(`Editing default locale record with id ${defaultEntityLocaleId}`);
+    const defaultEntityLocaleId = entityRecord.defaultEntityLocaleId || entityRecord.id;
+    if (entityRecord.defaultEntityLocaleId) {
+      this.logger.debug(`Editing translated locale record. Translation root id: ${defaultEntityLocaleId}`);
     } else {
-      defaultEntityLocaleId = entityRecord.defaultEntityLocaleId;
-      this.logger.debug(`Editing non-default locale record. DefaultEntityLocaleId: ${defaultEntityLocaleId}`);
+      this.logger.debug(`Editing translation root record with id ${defaultEntityLocaleId}`);
     }
 
     const records = await currentEntityRepository.find({
@@ -438,10 +502,20 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
 
   async upsert(updateSolidViewDto: UpdateViewMetadataDto) {
     // First check if module already exists using name
-    const existingSolidView = await this.findOneByUserKey(updateSolidViewDto.name);
+    const existingSolidView = await this.findOneByUserKey(updateSolidViewDto.name, {
+      module: true,
+      model: true,
+    });
 
     // if found
     if (existingSolidView) {
+      const hasChanges = this.hasChanges(existingSolidView, updateSolidViewDto);
+
+      if (!hasChanges) {
+        this.logger.debug(`Skipping view upsert for ${updateSolidViewDto.name}; no changes detected.`);
+        return existingSolidView;
+      }
+
       const updatedSolidViewDto = { ...existingSolidView, ...updateSolidViewDto };
       return this.repo.save(updatedSolidViewDto);
     }