Fixed PR comments

Author: cs-raj

packages/contentstack-audit/src/audit-base-command.ts

@@ -19,13 +19,15 @@ import {
   Workflows,
   Assets,
   FieldRule,
-  ReadModulesAndGetData,
+  ModuleDataReader,
   CustomRoles,
 } from './modules';
 
 import {
   CommandNames,
   ContentTypeStruct,
+  CtConstructorParam,
+  ModuleConstructorParam,
   OutputColumn,
   RefErrorReturnType,
   WorkflowExtensionsRefErrorReturnType,
@@ -74,7 +76,7 @@ export abstract class AuditBaseCommand extends BaseCommand<typeof AuditBaseComma
       missingMultipleFields,
     } = await this.scanAndFix();
 
-    if (this.flags['show-console-output'] || this.flags['s']) {
+    if (this.flags['show-console-output']) {
       this.showOutputOnScreen([
         { module: 'Content types', missingRefs: missingCtRefs },
         { module: 'Global Fields', missingRefs: missingGfRefs },
@@ -103,8 +105,8 @@ export abstract class AuditBaseCommand extends BaseCommand<typeof AuditBaseComma
         { module: 'Entries Changed Multiple Fields', missingRefs: missingMultipleFields },
       ]);
 
-      this.showOutputOnScreenWorkflowsAndExtension([{ module: 'Summary', missingRefs: this.summaryDataToPrint }]);
     }
+    this.showOutputOnScreenWorkflowsAndExtension([{ module: 'Summary', missingRefs: this.summaryDataToPrint }]);
 
     if (
       !isEmpty(missingCtRefs) ||
@@ -174,18 +176,17 @@ export abstract class AuditBaseCommand extends BaseCommand<typeof AuditBaseComma
       missingEnvLocalesInAssets,
       missingEnvLocalesInEntries,
       missingFieldRules,
-      missingMultipleFields,
-      DataModuleWise: Record<string, any>;
+      missingMultipleFields;
 
-    const constructorParam: any = {
+    const constructorParam: ModuleConstructorParam & CtConstructorParam = {
       ctSchema,
       gfSchema,
       log: this.log,
       config: this.sharedConfig,
       fix: this.currentCommand === 'cm:stacks:audit:fix',
     };
 
-    DataModuleWise = await new ReadModulesAndGetData(cloneDeep(constructorParam)).run();
+    let dataModuleWise: Record<string,any> = await new ModuleDataReader(cloneDeep(constructorParam)).run();
     for (const module of this.sharedConfig.flags.modules || this.sharedConfig.modules) {
       print([
         {
@@ -201,17 +202,17 @@ export abstract class AuditBaseCommand extends BaseCommand<typeof AuditBaseComma
         case 'assets':
           missingEnvLocalesInAssets = await new Assets(cloneDeep(constructorParam)).run();
           await this.prepareReport(module, missingEnvLocalesInAssets);
-          this.getAffectedData('assets', DataModuleWise['assets'], missingEnvLocalesInAssets);
+          this.getAffectedData('assets', dataModuleWise['assets'], missingEnvLocalesInAssets);
           break;
         case 'content-types':
           missingCtRefs = await new ContentType(cloneDeep(constructorParam)).run();
           await this.prepareReport(module, missingCtRefs);
-          this.getAffectedData('content-types', DataModuleWise['content-types'], missingCtRefs);
+          this.getAffectedData('content-types', dataModuleWise['content-types'], missingCtRefs);
           break;
         case 'global-fields':
           missingGfRefs = await new GlobalField(cloneDeep(constructorParam)).run();
           await this.prepareReport(module, missingGfRefs);
-          this.getAffectedData('global-fields', DataModuleWise['global-fields'], missingGfRefs);
+          this.getAffectedData('global-fields', dataModuleWise['global-fields'], missingGfRefs);
           break;
         case 'entries':
           missingEntry = await new Entries(cloneDeep(constructorParam)).run();
@@ -232,7 +233,7 @@ export abstract class AuditBaseCommand extends BaseCommand<typeof AuditBaseComma
           await this.prepareReport('Entry_Missing_Locale_and_Env_in_Publish_Details', missingEnvLocalesInEntries);
 
           await this.prepareReport('Entry_Multiple_Fields', missingMultipleFields);
-          this.getAffectedData('entries', DataModuleWise['entries'], missingEntry);
+          this.getAffectedData('entries', dataModuleWise['entries'], missingEntry);
 
           break;
         case 'workflows':
@@ -244,24 +245,24 @@ export abstract class AuditBaseCommand extends BaseCommand<typeof AuditBaseComma
             fix: this.currentCommand === 'cm:stacks:audit:fix',
           }).run();
           await this.prepareReport(module, missingCtRefsInWorkflow);
-          this.getAffectedData('workflows', DataModuleWise['workflows'], missingCtRefsInWorkflow);
+          this.getAffectedData('workflows', dataModuleWise['workflows'], missingCtRefsInWorkflow);
 
           break;
         case 'extensions':
           missingCtRefsInExtensions = await new Extensions(cloneDeep(constructorParam)).run();
           await this.prepareReport(module, missingCtRefsInExtensions);
-          this.getAffectedData('extensions', DataModuleWise['extensions'], missingCtRefsInExtensions);
+          this.getAffectedData('extensions', dataModuleWise['extensions'], missingCtRefsInExtensions);
           break;
         case 'custom-roles':
           missingRefInCustomRoles = await new CustomRoles(cloneDeep(constructorParam)).run();
           await this.prepareReport(module, missingRefInCustomRoles);
-          this.getAffectedData('custom-roles', DataModuleWise['custom-roles'], missingRefInCustomRoles);
+          this.getAffectedData('custom-roles', dataModuleWise['custom-roles'], missingRefInCustomRoles);
 
           break;
         case 'field-rules':
           missingFieldRules = await new FieldRule(cloneDeep(constructorParam)).run();
           await this.prepareReport(module, missingFieldRules);
-          this.getAffectedData('field-rules', DataModuleWise['content-types'], missingFieldRules);
+          this.getAffectedData('field-rules', dataModuleWise['content-types'], missingFieldRules);
           break;
       }
 

packages/contentstack-audit/src/base-command.ts

@@ -40,7 +40,6 @@ export abstract class BaseCommand<T extends typeof Command> extends Command {
       description: commonMsg.DATA_DIR,
     }),
     'show-console-output': Flags.boolean({
-      char: 's',
       helpGroup: 'COMMON',
       description: commonMsg.SHOW_CONSOLE_OUTPUT,
     }),

packages/contentstack-audit/src/modules/index.ts

@@ -6,6 +6,6 @@ import Extensions from './extensions';
 import CustomRoles from './custom-roles';
 import Assets from './assets';
 import FieldRule from './field_rules';
-import ReadModulesAndGetData from './modulesData';
+import ModuleDataReader from './modulesData';
 
-export { Entries, GlobalField, ContentType, Workflows, Extensions, Assets, CustomRoles, FieldRule, ReadModulesAndGetData };
+export { Entries, GlobalField, ContentType, Workflows, Extensions, Assets, CustomRoles, FieldRule, ModuleDataReader };

packages/contentstack-audit/src/modules/modulesData.ts

@@ -11,7 +11,7 @@ import {
 import { keys, values } from 'lodash';
 
 
-export default class ReadModulesAndGetData {
+export default class ModuleDataReader {
   public log: LogFn;
   public config: ConfigType;
   public folderPath: string;
@@ -31,17 +31,17 @@ export default class ReadModulesAndGetData {
     this.folderPath = resolve(sanitizePath(config.basePath));
   }
 
-  async readModulesExceptEntry(moduleName: string): Promise<number> {
-    let data =0;
+  async getModuleItemCount(moduleName: string): Promise<number> {
+    let count = 0;
     switch (moduleName) {
       case "content-types":
-        data = this.ctSchema.length;
+        count = this.ctSchema.length;
         break;
       case 'global-fields':
-        data = this.gfSchema.length;
+        count = this.gfSchema.length;
         break;
       case 'assets': 
-        data = keys(await this.ReadEntryAssetsModule(this.folderPath,'assets')).length;
+        count = keys(await this.readEntryAssetsModule(this.folderPath,'assets')).length;
         break;
       case 'entries':
         {
@@ -53,21 +53,18 @@ export default class ReadModulesAndGetData {
           if (existsSync(localesPath)) {
             this.locales.push(...values(JSON.parse(readFileSync(localesPath, 'utf8'))));
           }
-          let count = 0;
           for (const {code} of this.locales) {
             for (const ctSchema of this.ctSchema) {
               const basePath = join(this.folderPath,'entries', ctSchema.uid, code);
-              data = await this.ReadEntryAssetsModule(basePath, 'index');
-              count = count + data;
+              count = count + await this.readEntryAssetsModule(basePath, 'index') || 0;
             }
           }
-          data = count;
         }
         break;
       case 'custom-roles':
       case 'extensions':
       case 'workflows':
-        data = keys(await (this.readUsingFsModule(
+        count = keys(await (this.readUsingFsModule(
           resolve(
             this.folderPath,
             sanitizePath(this.config.moduleConfig[moduleName].dirName),
@@ -76,7 +73,7 @@ export default class ReadModulesAndGetData {
         ))).length;
         break;
     }
-    return data;
+    return count;
 
   }
 
@@ -85,7 +82,7 @@ export default class ReadModulesAndGetData {
     return data;
   }
 
-  async ReadEntryAssetsModule(basePath: string, module: string): Promise<number> {
+  async readEntryAssetsModule(basePath: string, module: string): Promise<number> {
     let fsUtility = new FsUtility({ basePath, indexFileName: `${module}.json` });
     let indexer = fsUtility.indexFileContent;
     let count = 0;
@@ -99,7 +96,7 @@ export default class ReadModulesAndGetData {
   async run(): Promise<Object> {
     await Promise.allSettled(
       Object.keys(this.config.moduleConfig).map(async (module) => {
-        this.auditData[module] = { Total: await this.readModulesExceptEntry(module) };
+        this.auditData[module] = { Total: await this.getModuleItemCount(module) };
       })
     );
     return this.auditData;