Merge pull request #238 from salesforcecli/u/abhinavkumar2/using_shelljs

Apex DR IP reference updates

Author: AbhinavKumar-sf

package.json

@@ -5,19 +5,21 @@
   "author": "Salesforce",
   "bugs": "https://github.com/forcedotcom/cli/issues",
   "dependencies": {
-    "@babel/parser": "^7.25.4",
     "@apexdevtools/apex-parser": "^4.1.0",
+    "@babel/parser": "^7.25.4",
     "@oclif/command": "^1",
     "@oclif/config": "^1",
     "@oclif/errors": "^1",
     "@salesforce/command": "^4.2.1",
     "@salesforce/core": "^2.37.1",
     "@types/jsdom": "^21.1.7",
     "@types/lodash.chunk": "^4.2.9",
+    "@types/shelljs": "^0.8.15",
     "cheerio": "^1.0.0",
     "jsdom": "^25.0.0",
     "lodash.chunk": "^4.2.0",
     "open": "^8.4.2",
+    "shelljs": "^0.8.5",
     "tslib": "^2",
     "xmldom": "^0.6.0"
   },

src/commands/omnistudio/migration/OmnistudioRelatedObjectMigrationFacade.ts

@@ -1,173 +1,101 @@
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import * as os from 'os';
-import { Messages } from '@salesforce/core';
+import { Org } from '@salesforce/core';
 import '../../../utils/prototypes';
-import { IConfig } from '@oclif/config';
-import OmniStudioBaseCommand from '../../basecommand';
-import { DebugTimer, MigratedObject, MigratedRecordInfo } from '../../../utils';
-import { MigrationResult, MigrationTool } from '../../../migration/interfaces';
-import { ResultsBuilder } from '../../../utils/resultsbuilder';
-import {
-  LWCComponentMigrationTool,
-  CustomLabelMigrationTool,
-  ApexClassMigrationTool,
-} from '../../../migration/interfaces';
+import { DebugTimer, MigratedObject } from '../../../utils';
+import { RelatedObjectsMigrate } from '../../../migration/interfaces';
+import { sfProject } from '../../../utils/sfcli/project/sfProject';
+import { Logger } from '../../../utils/logger';
+import { ApexMigration } from '../../../migration/related/ApexMigration';
 
 // Initialize Messages with the current plugin directory
-Messages.importMessagesDirectory(__dirname);
+// Messages.importMessagesDirectory(__dirname);
 
 // Load the specific messages for this file. Messages from @salesforce/command, @salesforce/core,
 // or any library that is using the messages framework can also be loaded this way.
-const messages = Messages.loadMessages('@salesforce/plugin-omnistudio-related-object-migration-tool', 'migrate');
+// const messages = Messages.loadMessages('@salesforce/plugin-omnistudio-related-object-migration-tool', 'migrate');
 
-export default class OmnistudioRelatedObjectMigrationFacade extends OmniStudioBaseCommand {
-  public static description = messages.getMessage('commandDescription');
-  public static examples = messages.getMessage('examples').split(os.EOL);
+const defaultProjectName = 'omnistudio_migration';
+export default class OmnistudioRelatedObjectMigrationFacade {
+  // public static description = messages.getMessage('commandDescription');
+  // public static examples = messages.getMessage('examples').split(os.EOL);
   public static args = [{ name: 'file' }];
 
   protected readonly namespace: string;
   protected readonly only: string;
   protected readonly allversions: boolean;
+  protected readonly org: Org;
 
-  public constructor(argv: string[], config: IConfig) {
-    super(argv, config);
-    const { flags } = this.parse(OmnistudioRelatedObjectMigrationFacade);
-    this.namespace = flags.namespace;
-    this.only = flags.only;
-    this.allversions = flags.allversions;
+  public constructor(namespace: string, only: string, allversions: boolean, org: Org) {
+    this.namespace = namespace;
+    this.only = only;
+    this.allversions = allversions;
+    this.org = org;
   }
-  public async migrateAll(migrationResult: MigrationResult, namespace: string, relatedObjects: string[]): Promise<any> {
-    const apiVersion = '55.0'; // Define the API version or make it configurable
-    const conn = this.org.getConnection();
-    conn.setApiVersion(apiVersion);
-
+  public migrateAll(migrationResult: MigratedObject[], relatedObjects: string[]): any {
     // Start the debug timer
     DebugTimer.getInstance().start();
 
     // Declare an array of MigrationTool
-    const migrationTools: MigrationTool[] = [];
-
+    const migrationTools: RelatedObjectsMigrate[] = [];
+    const projectDirectory: string = this.intializeProject();
+    const debugTimer = DebugTimer.getInstance();
+    debugTimer.start();
     // Initialize migration tools based on the relatedObjects parameter
     if (relatedObjects.includes('lwc')) {
-      migrationTools.push(this.createLWCComponentMigrationTool(namespace, conn));
+      migrationTools.push(this.createLWCComponentMigrationTool(this.namespace, this.org));
     }
     if (relatedObjects.includes('labels')) {
-      migrationTools.push(this.createCustomLabelMigrationTool(namespace, conn));
+      migrationTools.push(this.createCustomLabelMigrationTool(this.namespace, this.org));
     }
     if (relatedObjects.includes('apex')) {
-      migrationTools.push(this.createApexClassMigrationTool(namespace, conn));
-    }
-
-    if (migrationTools.length === 0) {
-      throw new Error(messages.getMessage('noMigrationToolsSelected'));
+      migrationTools.push(this.createApexClassMigrationTool(projectDirectory));
     }
 
     // Proceed with migration logic
-    const debugTimer = DebugTimer.getInstance();
-    let objectMigrationResults: MigratedObject[] = [];
-
-    // Truncate existing objects if necessary
-    let allTruncateComplete = true;
-    for (const tool of migrationTools.reverse()) {
+    for (const migrationTool of migrationTools.reverse()) {
       try {
-        this.ux.log('Cleaning: ' + tool.getName());
-        debugTimer.lap('Cleaning: ' + tool.getName());
-        await tool.truncate();
-      } catch (ex: any) {
-        allTruncateComplete = false;
-        objectMigrationResults.push({
-          name: tool.getName(),
-          errors: [ex.message],
-        });
-      }
-    }
-
-    if (allTruncateComplete) {
-      for (const tool of migrationTools.reverse()) {
-        try {
-          this.ux.log('Migrating: ' + tool.getName());
-          debugTimer.lap('Migrating: ' + tool.getName());
-          const results = await tool.migrate();
-
-          objectMigrationResults = objectMigrationResults.concat(
-            results.map((r) => ({
-              name: r.name,
-              data: this.mergeRecordAndUploadResults(r, tool),
-            }))
-          );
-        } catch (ex: any) {
-          this.logger.error(JSON.stringify(ex));
-          objectMigrationResults.push({
-            name: tool.getName(),
-            errors: [ex.message],
-          });
-        }
+        migrationTool.migrateRelatedObjects(null, null);
+      } catch (Error) {
+        // Log the error
+        Logger.logger.error(Error.message);
+        return { migrationResult };
       }
     }
-
+    // Truncate existing objects if necessary
     // Stop the debug timer
-    const timer = DebugTimer.getInstance().stop();
-
-    await ResultsBuilder.generate(objectMigrationResults, conn.instanceUrl);
+    const timer = debugTimer.stop();
 
     // Save timer to debug logger
-    this.logger.debug(timer);
+    Logger.logger.debug(timer);
 
     // Return results needed for --json flag
-    return { objectMigrationResults };
+    return { migrationResult };
   }
 
   // Factory methods to create instances of specific tools
-  private createLWCComponentMigrationTool(namespace: string, conn: any): LWCComponentMigrationTool {
+  private createLWCComponentMigrationTool(namespace: string, org: Org): RelatedObjectsMigrate {
     // Return an instance of LWCComponentMigrationTool when implemented
     throw new Error('LWCComponentMigrationTool implementation is not provided yet.');
   }
 
-  private createCustomLabelMigrationTool(namespace: string, conn: any): CustomLabelMigrationTool {
+  private createCustomLabelMigrationTool(namespace: string, org: Org): RelatedObjectsMigrate {
     // Return an instance of CustomLabelMigrationTool when implemented
     throw new Error('CustomLabelMigrationTool implementation is not provided yet.');
   }
 
-  private createApexClassMigrationTool(namespace: string, conn: any): ApexClassMigrationTool {
+  private createApexClassMigrationTool(projectPath: string): ApexMigration {
     // Return an instance of ApexClassMigrationTool when implemented
-    throw new Error('ApexClassMigrationTool implementation is not provided yet.');
+    return new ApexMigration(projectPath, this.namespace, this.org);
   }
-
-  private mergeRecordAndUploadResults(
-    migrationResults: MigrationResult,
-    migrationTool: MigrationTool
-  ): MigratedRecordInfo[] {
-    const mergedResults: MigratedRecordInfo[] = [];
-
-    for (const record of Array.from(migrationResults.records.values())) {
-      const obj = {
-        id: record['Id'],
-        name: migrationTool.getRecordName(record),
-        status: 'Skipped',
-        errors: record['errors'],
-        migratedId: undefined,
-        warnings: [],
-        migratedName: '',
-      };
-
-      if (migrationResults.results.has(record['Id'])) {
-        const recordResults = migrationResults.results.get(record['Id']);
-
-        let errors: any[] = obj.errors || [];
-        errors = errors.concat(recordResults.errors || []);
-
-        obj.status = !recordResults || recordResults.hasErrors ? 'Error' : 'Complete';
-        obj.errors = errors;
-        obj.migratedId = recordResults.id;
-        obj.warnings = recordResults.warnings;
-        obj.migratedName = recordResults.newName;
-      }
-
-      mergedResults.push(obj);
+  private intializeProject(projectPath?: string): string {
+    if (projectPath) {
+      sfProject.create(defaultProjectName, projectPath);
+      return projectPath + '/' + defaultProjectName;
+    } else {
+      sfProject.create(defaultProjectName);
+      return process.cwd() + '/' + defaultProjectName;
     }
-
-    return mergedResults;
   }
 }

src/commands/omnistudio/migration/migrate.ts

@@ -19,6 +19,7 @@ import { ResultsBuilder } from '../../../utils/resultsbuilder';
 import { CardMigrationTool } from '../../../migration/flexcard';
 import { OmniScriptExportType, OmniScriptMigrationTool } from '../../../migration/omniscript';
 import { Logger } from '../../../utils/logger';
+import OmnistudioRelatedObjectMigrationFacade from './OmnistudioRelatedObjectMigrationFacade';
 
 // Initialize Messages with the current plugin directory
 Messages.importMessagesDirectory(__dirname);
@@ -56,6 +57,7 @@ export default class Migrate extends OmniStudioBaseCommand {
     const apiVersion = (this.flags.apiversion || '55.0') as string;
     const migrateOnly = (this.flags.only || '') as string;
     const allVersions = this.flags.allversions || false;
+
     Logger.initialiseLogger(this.ux, this.logger);
     this.logger = Logger.logger;
     // this.org is guaranteed because requiresUsername=true, as opposed to supportsUsername
@@ -123,7 +125,6 @@ export default class Migrate extends OmniStudioBaseCommand {
     // Migrate individual objects
     const debugTimer = DebugTimer.getInstance();
     let objectMigrationResults: MigratedObject[] = [];
-
     // We need to truncate the standard objects first
     let allTruncateComplete = true;
     for (const cls of migrationObjects.reverse()) {
@@ -168,6 +169,13 @@ export default class Migrate extends OmniStudioBaseCommand {
     // Stop the debug timer
     const timer = DebugTimer.getInstance().stop();
 
+    const omnistudioRelatedObjectsMigration = new OmnistudioRelatedObjectMigrationFacade(
+      namespace,
+      migrateOnly,
+      allVersions,
+      this.org
+    );
+    omnistudioRelatedObjectsMigration.migrateAll(objectMigrationResults, []);
     await ResultsBuilder.generate(objectMigrationResults, conn.instanceUrl);
 
     // save timer to debug logger

src/migration/interfaces.ts

@@ -91,7 +91,7 @@ export interface RelatedObjectsMigrate {
    * @param namespace The namespace used to identify objects.
    * @returns List of identified migration candidates as strings.
    */
-  identifyObjects(migrationResults: MigrationResult[], namespace: string): Promise<string[]>;
+  identifyObjects(migrationResults: MigrationResult[]): Promise<JSON[]>;
 
   /**
    * Private method to perform the migration of related objects based on the provided candidates.
@@ -100,15 +100,9 @@ export interface RelatedObjectsMigrate {
    * @param namespace The namespace used to perform the migration.
    * @param migrationCandidates List of candidates to migrate.
    */
-  migrateRelatedObjects(
-    migrationResults: MigrationResult[],
-    namespace: string,
-    migrationCandidates: string[]
-  ): Promise<void>;
+  migrateRelatedObjects(migrationResults: MigrationResult[], migrationCandidates: JSON[]): void;
 }
 
 export type LWCComponentMigrationTool = MigrationTool;
 
 export type CustomLabelMigrationTool = MigrationTool;
-
-export type ApexClassMigrationTool = MigrationTool;

src/migration/related/ApexMigration.ts

@@ -0,0 +1,54 @@
+import * as fs from 'fs';
+// import { RetrieveResult } from '@salesforce/source-deploy-retrieve';
+// import { sfcclicommand } from '../../utils/sfcli/commands/sfclicommand';
+import * as shell from 'shelljs';
+import { Org } from '@salesforce/core';
+import { ApexASTParser, MethodCall } from '../../utils/apex/parser/apexparser';
+import { MigrationResult, RelatedObjectsMigrate } from '../interfaces';
+import { sfProject } from '../../utils/sfcli/project/sfProject';
+import { fileutil, File } from '../../utils/file/fileutil';
+import { BaseRelatedObjectMigration } from './BaseRealtedObjectMigration';
+const APEXCLASS = 'Apexclass';
+const APEX_CLASS_PATH = '/force-app/main/default/classes';
+export class ApexMigration extends BaseRelatedObjectMigration implements RelatedObjectsMigrate {
+  public identifyObjects(migrationResults: MigrationResult[]): Promise<JSON[]> {
+    throw new Error('Method not implemented.');
+  }
+  public migrateRelatedObjects(migrationResults: MigrationResult[], migrationCandidates: JSON[]): void {
+    this.migrate();
+  }
+  public migrate(): void {
+    const pwd = shell.pwd();
+    shell.cd(this.projectPath);
+    const targetOrg: Org = this.org;
+    sfProject.retrieve(APEXCLASS, targetOrg.getUsername());
+    this.processApexFiles(this.projectPath);
+    sfProject.deploy(APEXCLASS, targetOrg.getUsername());
+    shell.cd(pwd);
+  }
+  public processApexFiles(dir: string): File[] {
+    dir += APEX_CLASS_PATH;
+    let files: File[] = [];
+    files = fileutil.readFilesSync(dir);
+    for (const file of files) {
+      if (file.ext !== '.cls') continue;
+      this.processApexFile(file);
+    }
+    return files;
+  }
+
+  public processApexFile(file: File): void {
+    const fileContent = fs.readFileSync(file.location, 'utf8');
+    const interfaces = new Set<string>(['VlocityOpenInterface', 'VlocityOpenInterface2', 'Callable']);
+    const methodCalls = new Set<MethodCall>();
+    methodCalls.add(new MethodCall('process', 'DRGlobal', this.namespace));
+    methodCalls.add(new MethodCall('processObjectsJSON', 'DRGlobal', this.namespace));
+    const parser = new ApexASTParser(fileContent, interfaces, methodCalls, this.namespace);
+    parser.parse();
+    this.processApexFileforDRCalls(file, fileContent);
+  }
+  public processApexFileforDRCalls(file: File, fileContent: string): void {
+    // fileContent = fileContent.replace(this.namespace + '.', 'omnistudio.');
+    fs.writeFileSync(file.location, fileContent, 'utf-8');
+  }
+}

src/migration/related/BaseRealtedObjectMigration.ts

@@ -0,0 +1,13 @@
+import { Org } from '@salesforce/core';
+
+export abstract class BaseRelatedObjectMigration {
+  public projectPath: string;
+  public namespace: string;
+  public org: Org;
+
+  public constructor(projectPath: string, namespace: string, org: Org) {
+    this.projectPath = projectPath;
+    this.namespace = namespace;
+    this.org = org;
+  }
+}