Merge pull request #442 from sf-aastha-paruthi/u/aparuthi/StandardModelFixesBlitz

Blitz fixes - P1 issues

Author: sf-aastha-paruthi

src/migration/dataraptor.ts

@@ -25,6 +25,7 @@ import { Logger } from '../utils/logger';
 import { createProgressBar } from './base';
 import { Constants } from '../utils/constants/stringContants';
 import { isStandardDataModel } from '../utils/dataModelService';
+import { prioritizeCleanNamesFirst } from '../utils/recordPrioritization';
 
 export class DataRaptorMigrationTool extends BaseMigrationTool implements MigrationTool {
   static readonly DRBUNDLE_NAME = 'DRBundle__c';
@@ -431,7 +432,7 @@ export class DataRaptorMigrationTool extends BaseMigrationTool implements Migrat
   // Get All DRBundle__c records
   private async getAllDataRaptors(): Promise<AnyJson[]> {
     //DebugTimer.getInstance().lap('Query DRBundle');
-    return await QueryTools.queryAll(
+    const dataRaptors = await QueryTools.queryAll(
       this.connection,
       this.getQueryNamespace(),
       this.getBundleObjectName(),
@@ -442,6 +443,13 @@ export class DataRaptorMigrationTool extends BaseMigrationTool implements Migrat
       }
       throw err;
     });
+
+    // Apply prioritization only for standard data model
+    if (this.IS_STANDARD_DATA_MODEL) {
+      return this.prioritizeDataRaptorsWithoutSpecialCharacters(dataRaptors);
+    }
+
+    return dataRaptors;
   }
 
   // Get All Items
@@ -609,4 +617,15 @@ export class DataRaptorMigrationTool extends BaseMigrationTool implements Migrat
       ? DataRaptorMigrationTool.OMNIDATATRANSFORMITEM_NAME
       : DataRaptorMigrationTool.DRMAPITEM_NAME;
   }
+
+  /**
+   * Prioritizes DataRaptors by name characteristics:
+   * - Clean names (alphanumeric only) are processed first
+   * - Names with special characters are processed after
+   * This avoids naming conflicts during migration when special characters are cleaned
+   */
+  private prioritizeDataRaptorsWithoutSpecialCharacters(dataRaptors: AnyJson[]): AnyJson[] {
+    const nameField = this.getBundleFieldKey('Name');
+    return prioritizeCleanNamesFirst(dataRaptors, nameField);
+  }
 }

src/migration/flexcard.ts

@@ -22,6 +22,7 @@ import { Constants } from '../utils/constants/stringContants';
 import { StorageUtil } from '../utils/storageUtil';
 import { getUpdatedAssessmentStatus } from '../utils/stringUtils';
 import { isStandardDataModel } from '../utils/dataModelService';
+import { prioritizeCleanNamesFirst } from '../utils/recordPrioritization';
 
 export class CardMigrationTool extends BaseMigrationTool implements MigrationTool {
   static readonly VLOCITYCARD_NAME = 'VlocityCard__c';
@@ -159,6 +160,7 @@ export class CardMigrationTool extends BaseMigrationTool implements MigrationToo
     try {
       Logger.log(this.messages.getMessage('startingFlexCardAssessment'));
       const flexCards = await this.getAllCards();
+
       Logger.log(this.messages.getMessage('foundFlexCardsToAssess', [flexCards.length]));
 
       const flexCardsAssessmentInfos = await this.processCardComponents(flexCards);
@@ -734,12 +736,14 @@ export class CardMigrationTool extends BaseMigrationTool implements MigrationToo
       filters.set(this.namespacePrefix + 'CardType__c', 'flex');
     }
 
+    let flexCards: AnyJson[];
+
     if (this.allVersions) {
       const sortFields = [
         { field: 'Name', direction: SortDirection.ASC },
         { field: this.getFieldKey('Version__c'), direction: SortDirection.ASC },
       ];
-      return await QueryTools.queryWithFilterAndSort(
+      flexCards = await QueryTools.queryWithFilterAndSort(
         this.connection,
         this.getQueryNamespace(),
         this.getCardObjectName(),
@@ -756,7 +760,7 @@ export class CardMigrationTool extends BaseMigrationTool implements MigrationToo
       });
     } else {
       filters.set(this.getFieldKey('Active__c'), true);
-      return await QueryTools.queryWithFilter(
+      flexCards = await QueryTools.queryWithFilter(
         this.connection,
         this.getQueryNamespace(),
         this.getCardObjectName(),
@@ -769,6 +773,13 @@ export class CardMigrationTool extends BaseMigrationTool implements MigrationToo
         throw err;
       });
     }
+
+    // Apply prioritization only for standard data model
+    if (this.IS_STANDARD_DATA_MODEL) {
+      return this.prioritizeFlexCardsWithoutSpecialCharacters(flexCards);
+    }
+
+    return flexCards;
   }
 
   // Upload All the VlocityCard__c records to OmniUiCard for custom model and update references for standard
@@ -1767,4 +1778,15 @@ export class CardMigrationTool extends BaseMigrationTool implements MigrationToo
     // Save the updated definition back to the mappedObject
     mappedObject[CardMappings.Definition__c] = JSON.stringify(definition);
   }
+
+  /**
+   * Prioritizes FlexCards by name characteristics:
+   * - Clean names (alphanumeric only) are processed first
+   * - Names with special characters are processed after
+   * This avoids naming conflicts during migration when special characters are cleaned
+   */
+  private prioritizeFlexCardsWithoutSpecialCharacters(flexCards: AnyJson[]): AnyJson[] {
+    const nameField = this.getFieldKey('Name');
+    return prioritizeCleanNamesFirst(flexCards, nameField);
+  }
 }

src/migration/omniscript.ts

@@ -39,6 +39,7 @@ import { Logger } from '../utils/logger';
 import { createProgressBar } from './base';
 import { StorageUtil } from '../utils/storageUtil';
 import { isStandardDataModel } from '../utils/dataModelService';
+import { prioritizeCleanNamesFirst } from '../utils/recordPrioritization';
 
 export class OmniScriptMigrationTool extends BaseMigrationTool implements MigrationTool {
   private readonly exportType: OmniScriptExportType;
@@ -1408,13 +1409,15 @@ export class OmniScriptMigrationTool extends BaseMigrationTool implements Migrat
       filters.set(this.getFieldKey('IsProcedure__c'), false);
     }
 
+    let omniscripts: AnyJson[];
+
     if (this.allVersions) {
       const sortFields = [
         { field: this.getFieldKey('Type__c'), direction: SortDirection.ASC },
         { field: this.getFieldKey('SubType__c'), direction: SortDirection.ASC },
         { field: this.getFieldKey('Version__c'), direction: SortDirection.ASC },
       ];
-      return await QueryTools.queryWithFilterAndSort(
+      omniscripts = await QueryTools.queryWithFilterAndSort(
         this.connection,
         this.getQueryNamespace(),
         this.getOmniscriptObjectName(),
@@ -1431,7 +1434,7 @@ export class OmniScriptMigrationTool extends BaseMigrationTool implements Migrat
       });
     } else {
       filters.set(this.getFieldKey('IsActive__c'), true);
-      return await QueryTools.queryWithFilter(
+      omniscripts = await QueryTools.queryWithFilter(
         this.connection,
         this.getQueryNamespace(),
         this.getOmniscriptObjectName(),
@@ -1444,6 +1447,13 @@ export class OmniScriptMigrationTool extends BaseMigrationTool implements Migrat
         throw err;
       });
     }
+
+    // Apply prioritization only for standard data model
+    if (this.IS_STANDARD_DATA_MODEL) {
+      return this.prioritizeOmniscriptsWithoutSpecialCharacters(omniscripts);
+    }
+
+    return omniscripts;
   }
 
   // Get All Elements w.r.t OmniScript__c i.e Elements tagged to passed in IP/OS
@@ -2135,6 +2145,19 @@ export class OmniScriptMigrationTool extends BaseMigrationTool implements Migrat
       : Object.keys(OmniScriptDefinitionMappings);
   }
 
+  /**
+   * Prioritizes OmniScripts by name characteristics:
+   * - Clean names (alphanumeric only) are processed first
+   * - Names with special characters are processed after
+   * This avoids naming conflicts during migration when special characters are cleaned
+   */
+  private prioritizeOmniscriptsWithoutSpecialCharacters(omniscripts: AnyJson[]): AnyJson[] {
+    // Check both Type__c and SubType__c fields
+    const typeField = this.getFieldKey('Type__c');
+    const subTypeField = this.getFieldKey('SubType__c');
+    return prioritizeCleanNamesFirst(omniscripts, [typeField, subTypeField]);
+  }
+
   /**
    * Collects reserved keys found in PropertySet tagsToValidate
    * @param propertySet - The PropertySet JSON object to validate

src/utils/apex/parser/apexparser.ts

@@ -21,6 +21,10 @@ import { CharStreams, ParserRuleContext, Token, TokenStreamRewriter } from 'antl
 import { ParseTreeWalker } from 'antlr4ts/tree/ParseTreeWalker';
 import { Logger } from '../../logger';
 
+// Constants for reserved keywords and special interface names
+const SYSTEM_NAMESPACE = 'System';
+const CALLABLE_INTERFACE = 'Callable';
+
 export class ApexASTParser {
   private apexFileContent: string;
   private implementsInterface: Map<InterfaceImplements, Token[]> = new Map();
@@ -260,6 +264,16 @@ export class InterfaceMatcher {
     ) {
       tokens.push(typeNameContexts[0].id().Identifier().symbol);
       tokens.push(typeNameContexts[1].id().Identifier().symbol);
+    } else if (
+      // Special case for System.Callable - "System" is a reserved keyword so Identifier() returns null
+      checkFor.namespace === SYSTEM_NAMESPACE &&
+      checkFor.name === CALLABLE_INTERFACE &&
+      typeNameContexts.length === 2 &&
+      !typeNameContexts[0]?.id()?.Identifier() && // System is a reserved keyword, no Identifier
+      typeNameContexts[1]?.id()?.Identifier()?.symbol?.text === CALLABLE_INTERFACE
+    ) {
+      tokens.push(typeNameContexts[0].start);
+      tokens.push(typeNameContexts[1].id().Identifier().symbol);
     }
     return tokens;
   }

src/utils/recordPrioritization.ts

@@ -0,0 +1,72 @@
+/**
+ * Utility functions for record prioritization based on name characteristics
+ */
+
+import { AnyJson } from '@salesforce/ts-types';
+
+/**
+ * Checks if a string is a valid alphanumeric name for migration:
+ * - Must start with a letter (a-z, A-Z)
+ * - Can contain letters and numbers (a-z, A-Z, 0-9) after the first character
+ * - Cannot start with a number
+ * - Cannot contain special characters
+ *
+ * @param str - The string to check
+ * @returns true if the string is valid (starts with letter, alphanumeric only), false otherwise
+ *
+ * @example
+ * hasOnlyAlphanumericCharacters('MyName123') // true
+ * hasOnlyAlphanumericCharacters('Test1') // true
+ * hasOnlyAlphanumericCharacters('123Test') // false - starts with number
+ * hasOnlyAlphanumericCharacters('My-Name') // false - contains special character
+ */
+export function hasOnlyAlphanumericCharacters(str: string): boolean {
+  // Must start with a letter, followed by any number of alphanumeric characters
+  return /^[a-zA-Z][a-zA-Z0-9]*$/.test(str);
+}
+
+/**
+ * Prioritizes records by partitioning them into two groups:
+ * - Group 1: Records with valid migration names (start with letter, alphanumeric only)
+ * - Group 2: Records with names that need cleaning (start with number or contain special characters)
+ *
+ * Returns Group 1 followed by Group 2, effectively prioritizing cleaner names
+ * for processing first. This helps avoid naming conflicts during migration when
+ * special characters are cleaned/removed or numbers are prefixed.
+ * This prevents the error in standard data model as when we try to update a record with special chars first
+ * which already has clean name record in database we get FIELD_INTEGRITY_EXCEPTION as we cannot create a duplicate record with the same identifier
+ *
+ * @param records - Array of records to prioritize
+ * @param fieldNames - Single field name or array of field names to check for each record
+ * @returns Array with records reordered (valid migration names first, then others)
+ *
+ * @example
+ * // Single field
+ * prioritizeCleanNamesFirst(flexCards, 'Name')
+ *
+ * // Multiple fields (all must be valid)
+ * prioritizeCleanNamesFirst(omniScripts, ['Type__c', 'SubType__c'])
+ */
+export function prioritizeCleanNamesFirst<T extends AnyJson>(records: T[], fieldNames: string | string[]): T[] {
+  const cleanNameRecords: T[] = []; // Only alphanumeric in names
+  const specialCharRecords: T[] = []; // Has special characters in names
+
+  const fieldsToCheck = Array.isArray(fieldNames) ? fieldNames : [fieldNames];
+
+  for (const record of records) {
+    // Extract values for all specified fields
+    const namesToCheck = fieldsToCheck.map((field) => (record[field] as string) || '');
+
+    // Check if all names are valid (start with letter, alphanumeric only)
+    const allAlphanumeric = namesToCheck.every((name) => name && hasOnlyAlphanumericCharacters(name));
+
+    if (allAlphanumeric) {
+      cleanNameRecords.push(record);
+    } else {
+      specialCharRecords.push(record);
+    }
+  }
+
+  // Return clean names first, then names with special characters
+  return [...cleanNameRecords, ...specialCharRecords];
+}

test/migration/flexcard-standard-datamodel.test.ts

@@ -613,4 +613,95 @@ describe('FlexCard Standard Data Model (Metadata API Disabled) - Assessment and
       expect(result.OmniUiCardKey).to.equal('TestCard/TestAuthor/1.0');
     });
   });
+
+  describe('Standard Data Model - FlexCard Prioritization with Migration Status', () => {
+    it('should set correct migration status for clean names vs special character names', async () => {
+      // Test FlexCards with clean names (should have Success status)
+      const cleanNameCards = [
+        {
+          Id: 'fc001',
+          Name: 'Flexcard001', // Clean name
+          DataSourceConfig: JSON.stringify({ type: 'None' }),
+          PropertySetConfig: JSON.stringify({ layout: 'Card' }),
+          IsActive: true,
+          OmniUiCardType: 'Parent',
+          VersionNumber: 1,
+        },
+        {
+          Id: 'fc002',
+          Name: 'Flexcard002', // Clean name
+          DataSourceConfig: JSON.stringify({ type: 'None' }),
+          PropertySetConfig: JSON.stringify({ layout: 'Card' }),
+          IsActive: true,
+          OmniUiCardType: 'Parent',
+          VersionNumber: 1,
+        },
+        {
+          Id: 'fc003',
+          Name: 'Flexcard003', // Clean name
+          DataSourceConfig: JSON.stringify({ type: 'None' }),
+          PropertySetConfig: JSON.stringify({ layout: 'Card' }),
+          IsActive: true,
+          OmniUiCardType: 'Parent',
+          VersionNumber: 1,
+        },
+      ];
+
+      // Test FlexCards with special characters (should have Warnings status)
+      const specialCharCards = [
+        {
+          Id: 'fc004',
+          Name: 'Flexcard_001', // Special character (underscore)
+          DataSourceConfig: JSON.stringify({ type: 'None' }),
+          PropertySetConfig: JSON.stringify({ layout: 'Card' }),
+          IsActive: true,
+          OmniUiCardType: 'Parent',
+          VersionNumber: 1,
+        },
+        {
+          Id: 'fc005',
+          Name: 'Flexcard_002', // Special character (underscore)
+          DataSourceConfig: JSON.stringify({ type: 'None' }),
+          PropertySetConfig: JSON.stringify({ layout: 'Card' }),
+          IsActive: true,
+          OmniUiCardType: 'Parent',
+          VersionNumber: 1,
+        },
+        {
+          Id: 'fc006',
+          Name: 'Flexcard_003', // Special character (underscore)
+          DataSourceConfig: JSON.stringify({ type: 'None' }),
+          PropertySetConfig: JSON.stringify({ layout: 'Card' }),
+          IsActive: true,
+          OmniUiCardType: 'Parent',
+          VersionNumber: 1,
+        },
+      ];
+
+      const duplicateSet = new Set<string>();
+
+      // Process clean name cards
+      for (const card of cleanNameCards) {
+        const result = await (cardTool as any).processFlexCard(card, duplicateSet);
+
+        // Verify clean names have "Ready for migration" status with no warnings
+        expect(result.name).to.equal(card.Name);
+        expect(result.oldName).to.equal(card.Name);
+        expect(result.migrationStatus).to.equal('Ready for migration');
+        expect(result.warnings).to.have.length(0);
+      }
+
+      // Process special character cards
+      for (const card of specialCharCards) {
+        const result = await (cardTool as any).processFlexCard(card, duplicateSet);
+
+        // Verify special character names have appropriate migration status
+        expect(result.oldName).to.equal(card.Name);
+        expect(result.name).to.not.equal(card.Name); // Name should be cleaned
+        // FlexCards with special characters may have different statuses based on complexity
+        expect(result.migrationStatus).to.be.oneOf(['Warnings', 'Needs manual intervention']);
+        expect(result.warnings).to.have.length.greaterThan(0);
+      }
+    });
+  });
 });