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

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/role-metadata.service.ts

@@ -14,6 +14,7 @@ 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()
@@ -126,66 +127,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?`);
+      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);
       }
     }
 
-    // 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);
-        }
-      }
-
-    }
-    // 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 +202,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,
@@ -438,10 +506,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);
     }

package/.claude/settings.local.json

@@ -1,15 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(node -e:*)",
-      "WebFetch(domain:docs.solidxai.com)",
-      "WebFetch(domain:github.com)",
-      "Read(//Users/oswald/projects/Solid_Starters/solidctl/**)",
-      "Read(//Users/oswald/projects/Solid_Starters/**)",
-      "Bash(find /Users/oswald/projects/Solid_Starters/solid-core-module -type d -name migration* -o -name *database*)"
-    ],
-    "additionalDirectories": [
-      "/Users/oswald/projects/Solid_Starters/solidctl"
-    ]
-  }
-}

package/src/services/1.js

@@ -1,6 +0,0 @@
-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