Merge pull request #244 from salesforcecli/u/shailesh-sf/W-16375935/automate-lwc-parser-updated

@w-16375935@: LWC parser automated changes, fix build errors

Author: Shailesh Pachbhai

package.json

@@ -6,7 +6,7 @@
   "bugs": "https://github.com/forcedotcom/cli/issues",
   "dependencies": {
     "@apexdevtools/apex-parser": "^4.1.0",
-    "@babel/parser": "^7.25.4",
+    "@babel/types": "^7.25.6",
     "@oclif/command": "^1",
     "@oclif/config": "^1",
     "@oclif/errors": "^1",
@@ -24,7 +24,7 @@
     "xmldom": "^0.6.0"
   },
   "devDependencies": {
-    "@babel/parser": "^7.25.4",
+    "@babel/parser": "^7.25.6",
     "@oclif/dev-cli": "^1",
     "@oclif/plugin-command-snapshot": "^3.3.15",
     "@oclif/plugin-help": "^3",
@@ -36,6 +36,7 @@
     "@salesforce/ts-sinon": "^1",
     "@types/babel__traverse": "^7.20.6",
     "@types/jsforce": "^1.11.5",
+    "@types/mocha": "^10.0.8",
     "@typescript-eslint/eslint-plugin": "^4.2.0",
     "@typescript-eslint/parser": "^4.2.0",
     "chai": "^4.4.1",

src/commands/omnistudio/migration/OmnistudioRelatedObjectMigrationFacade.ts

@@ -8,6 +8,7 @@ import { RelatedObjectsMigrate } from '../../../migration/interfaces';
 import { sfProject } from '../../../utils/sfcli/project/sfProject';
 import { Logger } from '../../../utils/logger';
 import { ApexMigration } from '../../../migration/related/ApexMigration';
+import { LwcMigration } from '../../../migration/related/LwcMigration';
 
 // Initialize Messages with the current plugin directory
 // Messages.importMessagesDirectory(__dirname);
@@ -44,7 +45,7 @@ export default class OmnistudioRelatedObjectMigrationFacade {
     debugTimer.start();
     // Initialize migration tools based on the relatedObjects parameter
     if (relatedObjects.includes('lwc')) {
-      migrationTools.push(this.createLWCComponentMigrationTool(this.namespace, this.org));
+      migrationTools.push(this.createLWCComponentMigrationTool(this.namespace, projectDirectory));
     }
     if (relatedObjects.includes('labels')) {
       migrationTools.push(this.createCustomLabelMigrationTool(this.namespace, this.org));
@@ -75,9 +76,9 @@ export default class OmnistudioRelatedObjectMigrationFacade {
   }
 
   // Factory methods to create instances of specific tools
-  private createLWCComponentMigrationTool(namespace: string, org: Org): RelatedObjectsMigrate {
+  private createLWCComponentMigrationTool(namespace: string, projectPath: string): LwcMigration {
     // Return an instance of LWCComponentMigrationTool when implemented
-    throw new Error('LWCComponentMigrationTool implementation is not provided yet.');
+    return new LwcMigration(projectPath, this.namespace, this.org);
   }
 
   private createCustomLabelMigrationTool(namespace: string, org: Org): RelatedObjectsMigrate {

src/migration/related/LwcMigration.ts

@@ -0,0 +1,89 @@
+/* eslint-disable @typescript-eslint/member-ordering */
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/explicit-member-accessibility */
+import * as shell from 'shelljs';
+import { Org } from '@salesforce/core';
+import { fileutil, File } from '../../utils/file/fileutil';
+import { MigrationResult } from '../interfaces';
+import { sfProject } from '../../utils/sfcli/project/sfProject';
+import { JavaScriptParser } from '../../utils/lwcparser/jsParser/JavaScriptParser';
+import { HTMLParser } from '../../utils/lwcparser/htmlParser/HTMLParser';
+import { XmlParser } from '../../utils/lwcparser/xmlParser/XmlParser';
+import { Logger } from '../../utils/logger';
+import { BaseRelatedObjectMigration } from './BaseRealtedObjectMigration';
+
+const LWC_DIR_PATH = '/force-app/main/default/lwc';
+const LWCTYPE = 'LightningComponentBundle';
+const XML_TAG_TO_REMOVE = 'runtimeNamespace';
+
+export class LwcMigration extends BaseRelatedObjectMigration {
+  public identifyObjects(migrationResults: MigrationResult[]): Promise<JSON[]> {
+    throw new Error('Method not implemented.');
+  }
+  public migrateRelatedObjects(migrationResults: MigrationResult[], migrationCandidates: JSON[]): void {
+    this.migrate();
+  }
+  // eslint-disable-next-line @typescript-eslint/member-ordering
+
+  public migrate(): void {
+    const pwd = shell.pwd();
+    shell.cd(this.projectPath);
+    const targetOrg: Org = this.org;
+    sfProject.retrieve(LWCTYPE, targetOrg.getUsername());
+    this.processLwcFiles(this.projectPath);
+    sfProject.deploy(LWCTYPE, targetOrg.getUsername());
+    shell.cd(pwd);
+  }
+
+  public processLwcFiles(dir: string): File[] {
+    dir += LWC_DIR_PATH;
+    let files: File[] = [];
+    try {
+      files = fileutil.readAllFiles(dir);
+      this.processFile(files);
+    } catch (error) {
+      Logger.logger.error('Error in reading files', error);
+    }
+    return files;
+  }
+
+  private processFile(files: File[]) {
+    try {
+      for (const file of files) {
+        Logger.logger.info(file.location + ' files is Processing');
+        if (file.ext === '.js') {
+          this.processJavascriptFile(file);
+        } else if (file.ext === '.html') {
+          this.processHtmlFile(file);
+        } else if (file.ext === '.xml') {
+          this.processXMLFile(file);
+        }
+      }
+    } catch (error) {
+      Logger.logger.error(error.message);
+    }
+  }
+
+  processJavascriptFile(file: File): void {
+    const jsParser = new JavaScriptParser();
+    const filePath = file.location;
+    const output = jsParser.replaceImportSource(filePath, this.namespace);
+    jsParser.saveToFile(filePath, output);
+  }
+
+  processHtmlFile(file: File): void {
+    const filePath: string = file.location;
+    const parse = new HTMLParser(filePath);
+    parse.replaceTags(this.namespace);
+    parse.saveToFile(filePath);
+  }
+
+  processXMLFile(file: File): void {
+    const filePath: string = file.location;
+    const parser = new XmlParser(filePath);
+    const xmlString = parser.removeNode(XML_TAG_TO_REMOVE);
+    parser.saveToFile(filePath, xmlString);
+  }
+}

src/utils/file/fileutil.ts

@@ -15,6 +15,32 @@ export class fileutil {
     });
     return files;
   }
+
+  public static readAllFiles(dirPath: string, fileList: File[] = []): File[] {
+    // Read the directory contents
+    const files = fs.readdirSync(dirPath);
+
+    files.forEach((filename) => {
+      // Construct the full file/directory path
+      const filePath = path.join(dirPath, filename);
+
+      // Check if the current path is a directory or a file
+      if (fs.statSync(filePath).isDirectory()) {
+        // If it's a directory, recurse into it
+        fileutil.readAllFiles(filePath, fileList);
+      } else {
+        const name = path.parse(filename).name;
+        const ext = path.parse(filename).ext;
+        const filepath = path.resolve(dirPath, filename);
+        const stat = fs.statSync(filepath);
+        const isFile = stat.isFile();
+        // If it's a file, add it to the fileList
+        if (isFile) fileList.push(new File(name, filepath, ext));
+      }
+    });
+
+    return fileList;
+  }
 }
 
 export class File {

src/utils/lwcparser/htmlParser/HTMLParser.ts

@@ -5,7 +5,10 @@
 import * as fs from 'fs';
 import * as cheerio from 'cheerio';
 
-class HTMLParser {
+const DEFAULT_NAMESPACE = 'c';
+const TAG = 'tag';
+
+export class HTMLParser {
   private parser: cheerio.CheerioAPI;
 
   // eslint-disable-next-line @typescript-eslint/explicit-member-accessibility
@@ -26,11 +29,27 @@ class HTMLParser {
   }
 
   // Method to replace custom tags
-  public replaceCustomTag(oldTag: string, newTag: string): void {
-    this.parser(oldTag).each((_, element) => {
-      const newElement = this.parser(`<${newTag}></${newTag}>`).html(this.parser(element).html());
-      this.parser(element).replaceWith(newElement);
+  public replaceTags(namespaceTag: string): string {
+    // Load the HTML into cheerio
+    const $ = this.parser;
+
+    // Find all tags that contain the substring "omnistudio" in their tag name
+    $('*').each((i, element) => {
+      if (element.type === TAG && element.name && element.name.includes(namespaceTag + '-')) {
+        // Create a new tag with the same content and attributes as the old tag
+        const newTag = DEFAULT_NAMESPACE + element.name.substring(element.name.indexOf('-'));
+        const newElement = $(`<${newTag}>`).html($(element).html());
+
+        // Copy all attributes from the old element to the new one
+        Object.keys(element.attribs).forEach((attr) => {
+          newElement.attr(attr, $(element).attr(attr));
+        });
+
+        // Replace the old element with the new one
+        $(element).replaceWith(newElement);
+      }
     });
+    return $.html();
   }
 
   // Method to save modified HTML back to a file
@@ -50,5 +69,3 @@ class HTMLParser {
     return this.parser.html();
   }
 }
-
-export default HTMLParser;

src/utils/lwcparser/jsParser/JavaScriptParser.ts

@@ -1,49 +1,53 @@
+/* eslint-disable @typescript-eslint/restrict-template-expressions */
 /* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
 /* eslint-disable no-console */
-/* eslint-disable @typescript-eslint/explicit-member-accessibility */
-// import * as fs from 'fs';
-// import { parse, type ParseResult } from '@babel/parser'; // Import all types from @babel/types
+import * as fs from 'fs';
+import * as parser from '@babel/parser';
+import traverse from '@babel/traverse';
+import generate from '@babel/generator';
+import * as t from '@babel/types';
 
-class JavaScriptParser {
-  // private fileContent: string;
-  private ast: File | null = null; // Specify the generic type argument
+const DEFAULT_NAMESPACE = 'c';
 
-  constructor(filePath: string) {
-    // this.fileContent = fs.readFileSync(filePath, 'utf-8');
-    this.ast = null;
-  }
+export class JavaScriptParser {
+  // Function to replace strings in import declarations and write back to file
+  public replaceImportSource(filePath: string, oldSource: string): string {
+    // Read the JavaScript file
+    const code = fs.readFileSync(filePath, 'utf-8');
 
-  // public parseCode(): void {
-  //   const parseResult: File = parse(this.fileContent, {
-  //     sourceType: 'module', // Use 'script' if you're parsing non-module code
-  //     plugins: ['jsx', 'typescript'], // Add plugins as needed
-  //   });
+    // Parse the code into an AST (Abstract Syntax Tree)
+    const ast = parser.parse(code, {
+      sourceType: 'module', // Specify that we are parsing an ES module
+      plugins: ['decorators'], // Include any relevant plugins if necessary (e.g., 'jsx', 'flow', etc.)
+    });
 
-  //   if (parseResult.type === 'File') {
-  //     this.ast = parseResult;
-  //   } else {
-  //     throw new Error("Parsing did not return a 'File' node as expected.");
-  //   }
-  // }
+    // Traverse the AST and modify import declarations
+    traverse(ast, {
+      ImportDeclaration(path) {
+        const importSource = path.node.source.value;
 
-  // Method to get the AST as a string
-  getAST(): string | null {
-    if (!this.ast) {
-      console.error('AST is not available. Please parse the code first.');
-      return null;
-    }
-    return JSON.stringify(this.ast, null, 2);
+        // Check if the import source contains the old substring
+        if (importSource.includes(oldSource + '/')) {
+          // Replace the old substring with the new substring
+          const updatedSource = importSource.replace(oldSource, DEFAULT_NAMESPACE);
+          // Update the AST with the new source
+          path.node.source = t.stringLiteral(updatedSource);
+        }
+      },
+    });
+    return generate(ast, {}, code).code;
   }
 
-  // Main method to process the file
-  processFile(): void {
-    // this.parseCode(); // Parse the JavaScript code
-    const astString = this.getAST(); // Get the AST as a string
-    if (astString) {
-      console.log(astString); // Output the AST
+  // Method to save modified HTML back to a file
+  public saveToFile(filePath: string, output: string): void {
+    try {
+      fs.writeFileSync(filePath, output, 'utf-8');
+      console.log(`Replaced import 'oldSource' with 'c' in file: ${filePath}`);
+    } catch (error) {
+      console.error(`Error writing file to disk: ${error}`);
+      throw error;
     }
   }
 }
-
-export default JavaScriptParser;

src/utils/lwcparser/xmlParser/XmlParser.ts

@@ -1,45 +1,61 @@
-/* eslint-disable @typescript-eslint/no-inferrable-types */
-/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
 /* eslint-disable @typescript-eslint/member-ordering */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/no-unsafe-call */
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/explicit-member-accessibility */
+import * as fs from 'fs';
 import { DOMParser, XMLSerializer } from 'xmldom';
 
 export class XmlParser {
   private xmlDoc: Document | null = null;
+  private fileContent: string;
 
-  constructor(private xmlString: string) {
-    this.parseXml();
+  constructor(private filePath: string) {
+    this.fileContent = fs.readFileSync(this.filePath, 'utf-8');
+    this.parseXml(this.fileContent);
   }
 
-  private parseXml(): void {
+  private parseXml(fileContent): void {
     const parser = new DOMParser();
-    this.xmlDoc = parser.parseFromString(this.xmlString, 'text/xml');
+    try {
+      this.xmlDoc = parser.parseFromString(fileContent, 'text/xml');
+    } catch (error) {
+      throw new Error('Error in xml parsing');
+    }
   }
 
-  public removeNode(tagName: string, index: number = 0): void {
+  public removeNode(tagName: string, index = 0): string {
     if (!this.xmlDoc) {
       throw new Error('XML document has not been parsed.');
     }
-
     const nodes = this.xmlDoc.getElementsByTagName(tagName);
 
     if (nodes.length > index) {
       const nodeToRemove = nodes[index];
       nodeToRemove.parentNode?.removeChild(nodeToRemove);
-    } else {
-      throw new Error(`No node found with tag name "${tagName}" at index ${index}.`);
+
+      const serializer = new XMLSerializer();
+      const xmlString: string = serializer.serializeToString(this.xmlDoc);
+      return xmlString;
+      // this.printResult(this.filePath, tagName, index);
     }
   }
 
-  public getXmlString(): string {
-    if (!this.xmlDoc) {
-      throw new Error('XML document has not been parsed.');
+  public saveToFile(outputFilePath: string, xmlString: string): void {
+    try {
+      fs.writeFileSync(outputFilePath, xmlString);
+      // eslint-disable-next-line no-console
+      console.log(`Modified HTML saved to ${outputFilePath}`);
+    } catch (error) {
+      // eslint-disable-next-line no-console, @typescript-eslint/restrict-template-expressions
+      console.error(`Error writing file to disk: ${error}`);
+      throw error;
     }
-
-    const serializer = new XMLSerializer();
-    return serializer.serializeToString(this.xmlDoc);
   }
+
+  // protected printResult(fileName: string, xmlTag: string, lineNumber: number): void {
+  //   console.log('FileName :' + fileName);
+  //   console.log('Tag to remove :' + xmlTag);
+  //   console.log('Line Number :', lineNumber);
+  // }
 }