Merge pull request #2234 from contentstack/v2-beta-dev

V2 beta release

Author: harshithad0703

.github/workflows/unit-test.yml

@@ -24,9 +24,13 @@ jobs:
         working-directory: ./packages/contentstack-command
         run: npm run test:unit
 
-      - name: Run tests for Contentstack Command
-        working-directory: ./packages/contentstack-command
-        run: npm run test:unit
+      # - name: Run tests for Contentstack Import Plugin
+      #   working-directory: ./packages/contentstack-import
+      #   run: npm run test:unit
+      
+      # - name: Run tests for Contentstack Export Plugin
+      #   working-directory: ./packages/contentstack-export
+      #   run: npm run test:unit
 
       - name: Run tests for Audit plugin
         working-directory: ./packages/contentstack-audit

.talismanrc

@@ -282,6 +282,7 @@ DESCRIPTION
   Display help for csdx.
 ```
 
+_See code: [@oclif/plugin-help](https://github.com/oclif/plugin-help/blob/v6.2.33/src/commands/help.ts)_
 _See code: [@oclif/plugin-help](https://github.com/oclif/plugin-help/blob/v6.2.33/src/commands/help.ts)_
 
 ## `csdx plugins`

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentstack/cli-audit",
-  "version": "1.14.2",
+  "version": "1.16.0",
   "description": "Contentstack audit plugin",
   "author": "Contentstack CLI",
   "homepage": "https://github.com/contentstack/cli",

packages/contentstack-audit/README.md

@@ -5,7 +5,7 @@ import { v4 as uuid } from 'uuid';
 import isEmpty from 'lodash/isEmpty';
 import { join, resolve } from 'path';
 import cloneDeep from 'lodash/cloneDeep';
-import { cliux, sanitizePath, TableFlags, TableHeader } from '@contentstack/cli-utilities';
+import { cliux, sanitizePath, TableFlags, TableHeader, log, configHandler } from '@contentstack/cli-utilities';
 import { createWriteStream, existsSync, mkdirSync, readFileSync, writeFileSync, rmSync } from 'fs';
 import config from './config';
 import { print } from './util/log';
@@ -31,11 +31,13 @@ import {
   OutputColumn,
   RefErrorReturnType,
   WorkflowExtensionsRefErrorReturnType,
+  AuditContext,
 } from './types';
 
 export abstract class AuditBaseCommand extends BaseCommand<typeof AuditBaseCommand> {
   private currentCommand!: CommandNames;
   private readonly summaryDataToPrint: Record<string, any> = [];
+  protected auditContext!: AuditContext;
   get fixStatus() {
     return {
       fixStatus: {
@@ -48,6 +50,19 @@ export abstract class AuditBaseCommand extends BaseCommand<typeof AuditBaseComma
     };
   }
 
+  /**
+   * Create audit context object similar to export command
+   */
+  private createAuditContext(moduleName?: string): AuditContext {
+    return {
+      command: this.context?.info?.command || 'cm:stacks:audit',
+      module: moduleName || 'audit',
+      email: configHandler.get('email') || '',
+      sessionId: this.context?.sessionId || '',
+      authenticationMethod: configHandler.get('authenticationMethod') || '',
+    };
+  }
+
   /**
    * The `start` function performs an audit on content types, global fields, entries, and workflows and displays
    * any missing references.
@@ -56,9 +71,17 @@ export abstract class AuditBaseCommand extends BaseCommand<typeof AuditBaseComma
    */
   async start(command: CommandNames): Promise<boolean> {
     this.currentCommand = command;
+    // Initialize audit context
+    this.auditContext = this.createAuditContext();
+    log.debug(`Starting audit command: ${command}`, this.auditContext);
+    log.info(`Starting audit command: ${command}`, this.auditContext);
+
+    
     await this.promptQueue();
     await this.createBackUp();
     this.sharedConfig.reportPath = resolve(this.flags['report-path'] || process.cwd(), 'audit-report');
+    log.debug(`Data directory: ${this.flags['data-dir']}`, this.auditContext);
+    log.debug(`Report path: ${this.flags['report-path'] || process.cwd()}`, this.auditContext);
 
     const {
       missingCtRefs,
@@ -122,13 +145,13 @@ export abstract class AuditBaseCommand extends BaseCommand<typeof AuditBaseComma
       !isEmpty(missingMultipleFields)
     ) {
       if (this.currentCommand === 'cm:stacks:audit') {
-        this.log(this.$t(auditMsg.FINAL_REPORT_PATH, { path: this.sharedConfig.reportPath }), 'warn');
+        log.warn(this.$t(auditMsg.FINAL_REPORT_PATH, { path: this.sharedConfig.reportPath }), this.auditContext);
       } else {
-        this.log(this.$t(this.messages.FIXED_CONTENT_PATH_MAG, { path: this.sharedConfig.basePath }), 'warn');
+        log.warn(this.$t(this.messages.FIXED_CONTENT_PATH_MAG, { path: this.sharedConfig.basePath }), this.auditContext);
       }
     } else {
-      this.log(this.messages.NO_MISSING_REF_FOUND, 'info');
-      this.log('');
+      log.info(this.messages.NO_MISSING_REF_FOUND, this.auditContext);
+      cliux.print('');
 
       if (
         this.flags['copy-dir'] &&
@@ -161,14 +184,24 @@ export abstract class AuditBaseCommand extends BaseCommand<typeof AuditBaseComma
    * and `missingEntryRefs`.
    */
   async scanAndFix() {
+    log.debug('Starting scan and fix process', this.auditContext);
     let { ctSchema, gfSchema } = this.getCtAndGfSchema();
+    log.info(`Retrieved ${ctSchema?.length || 0} content types and ${gfSchema?.length || 0} global fields`, this.auditContext);
+    
     let missingCtRefs,
       missingGfRefs,
       missingEntryRefs,
       missingCtRefsInExtensions,
       missingCtRefsInWorkflow,
       missingSelectFeild,
-      missingEntry,
+      missingEntry: {
+        missingEntryRefs?: Record<string, any>;
+        missingSelectFeild?: Record<string, any>;
+        missingMandatoryFields?: Record<string, any>;
+        missingTitleFields?: Record<string, any>;
+        missingEnvLocale?: Record<string, any>;
+        missingMultipleFields?: Record<string, any>;
+      } = {},
       missingMandatoryFields,
       missingTitleFields,
       missingRefInCustomRoles,
@@ -180,13 +213,21 @@ export abstract class AuditBaseCommand extends BaseCommand<typeof AuditBaseComma
     const constructorParam: ModuleConstructorParam & CtConstructorParam = {
       ctSchema,
       gfSchema,
-      log: this.log,
-      config: this.sharedConfig,
+      config: {
+        ...this.sharedConfig,
+        auditContext: this.auditContext,
+      },
       fix: this.currentCommand === 'cm:stacks:audit:fix',
     };
 
     let dataModuleWise: Record<string, any> = await new ModuleDataReader(cloneDeep(constructorParam)).run();
+    log.debug(`Data module wise: ${JSON.stringify(dataModuleWise)}`, this.auditContext);
     for (const module of this.sharedConfig.flags.modules || this.sharedConfig.modules) {
+      // Update audit context with current module
+      this.auditContext = this.createAuditContext(module);
+      log.debug(`Starting audit for module: ${module}`, this.auditContext);
+      log.info(`Starting audit for module: ${module}`, this.auditContext);
+
       print([
         {
           bold: true,
@@ -199,21 +240,28 @@ export abstract class AuditBaseCommand extends BaseCommand<typeof AuditBaseComma
 
       switch (module) {
         case 'assets':
+          log.info('Executing assets audit', this.auditContext);
           missingEnvLocalesInAssets = await new Assets(cloneDeep(constructorParam)).run();
           await this.prepareReport(module, missingEnvLocalesInAssets);
           this.getAffectedData('assets', dataModuleWise['assets'], missingEnvLocalesInAssets);
+          log.success(`Assets audit completed. Found ${Object.keys(missingEnvLocalesInAssets || {}).length} issues`, this.auditContext);
           break;
         case 'content-types':
+          log.info('Executing content-types audit', this.auditContext);
           missingCtRefs = await new ContentType(cloneDeep(constructorParam)).run();
           await this.prepareReport(module, missingCtRefs);
           this.getAffectedData('content-types', dataModuleWise['content-types'], missingCtRefs);
+          log.success(`Content-types audit completed. Found ${Object.keys(missingCtRefs || {}).length} issues`, this.auditContext);
           break;
         case 'global-fields':
+          log.info('Executing global-fields audit', this.auditContext);
           missingGfRefs = await new GlobalField(cloneDeep(constructorParam)).run();
           await this.prepareReport(module, missingGfRefs);
           this.getAffectedData('global-fields', dataModuleWise['global-fields'], missingGfRefs);
+          log.success(`Global-fields audit completed. Found ${Object.keys(missingGfRefs || {}).length} issues`, this.auditContext);
           break;
         case 'entries':
+          log.info('Executing entries audit', this.auditContext);
           missingEntry = await new Entries(cloneDeep(constructorParam)).run();
           missingEntryRefs = missingEntry.missingEntryRefs ?? {};
           missingSelectFeild = missingEntry.missingSelectFeild ?? {};
@@ -233,39 +281,47 @@ export abstract class AuditBaseCommand extends BaseCommand<typeof AuditBaseComma
 
           await this.prepareReport('Entry_Multiple_Fields', missingMultipleFields);
           this.getAffectedData('entries', dataModuleWise['entries'], missingEntry);
+          log.success(`Entries audit completed. Found ${Object.keys(missingEntryRefs || {}).length} reference issues`, this.auditContext);
 
           break;
         case 'workflows':
+          log.info('Executing workflows audit', this.auditContext);
           missingCtRefsInWorkflow = await new Workflows({
             ctSchema,
-            log: this.log,
             moduleName: module,
             config: this.sharedConfig,
             fix: this.currentCommand === 'cm:stacks:audit:fix',
           }).run();
           await this.prepareReport(module, missingCtRefsInWorkflow);
           this.getAffectedData('workflows', dataModuleWise['workflows'], missingCtRefsInWorkflow);
+          log.success(`Workflows audit completed. Found ${Object.keys(missingCtRefsInWorkflow || {}).length} issues`, this.auditContext);
 
           break;
         case 'extensions':
+          log.info('Executing extensions audit', this.auditContext);
           missingCtRefsInExtensions = await new Extensions(cloneDeep(constructorParam)).run();
           await this.prepareReport(module, missingCtRefsInExtensions);
           this.getAffectedData('extensions', dataModuleWise['extensions'], missingCtRefsInExtensions);
+          log.success(`Extensions audit completed. Found ${Object.keys(missingCtRefsInExtensions || {}).length} issues`, this.auditContext);
           break;
         case 'custom-roles':
+          log.info('Executing custom-roles audit', this.auditContext);
           missingRefInCustomRoles = await new CustomRoles(cloneDeep(constructorParam)).run();
           await this.prepareReport(module, missingRefInCustomRoles);
           this.getAffectedData('custom-roles', dataModuleWise['custom-roles'], missingRefInCustomRoles);
+          log.success(`Custom-roles audit completed. Found ${Object.keys(missingRefInCustomRoles || {}).length} issues`, this.auditContext);
 
           break;
         case 'field-rules':
+          log.info('Executing field-rules audit', this.auditContext);
           // NOTE: We are using the fixed content-type for validation of field rules
           const data =  this.getCtAndGfSchema();
           constructorParam.ctSchema = data.ctSchema;
           constructorParam.gfSchema = data.gfSchema;
           missingFieldRules = await new FieldRule(cloneDeep(constructorParam)).run();
           await this.prepareReport(module, missingFieldRules);
           this.getAffectedData('field-rules', dataModuleWise['content-types'], missingFieldRules);
+          log.success(`Field-rules audit completed. Found ${Object.keys(missingFieldRules || {}).length} issues`, this.auditContext);
           break;
       }
 
@@ -283,6 +339,7 @@ export abstract class AuditBaseCommand extends BaseCommand<typeof AuditBaseComma
       ]);
     }
 
+    log.debug('Scan and fix process completed', this.auditContext);
     this.prepareReport('Summary', this.summaryDataToPrint);
     this.prepareCSV('Summary', this.summaryDataToPrint);
     return {
@@ -376,7 +433,7 @@ export abstract class AuditBaseCommand extends BaseCommand<typeof AuditBaseComma
    */
   showOutputOnScreen(allMissingRefs: { module: string; missingRefs?: Record<string, any> }[]) {
     if (this.sharedConfig.showTerminalOutput && !this.flags['external-config']?.noTerminalOutput) {
-      this.log(''); // NOTE adding new line
+      cliux.print(''); // NOTE adding new line
       for (const { module, missingRefs } of allMissingRefs) {
         if (!isEmpty(missingRefs)) {
           print([
@@ -423,7 +480,7 @@ export abstract class AuditBaseCommand extends BaseCommand<typeof AuditBaseComma
           ];
 
           cliux.table(tableHeaders, tableValues, { ...(this.flags as TableFlags) });
-          this.log(''); // NOTE adding new line
+          cliux.print(''); // NOTE adding new line
         }
       }
     }
@@ -434,15 +491,15 @@ export abstract class AuditBaseCommand extends BaseCommand<typeof AuditBaseComma
     if (!this.sharedConfig.showTerminalOutput || this.flags['external-config']?.noTerminalOutput) {
       return;
     }
-    this.log(''); // Adding a new line
+    cliux.print(''); // Adding a new line
 
     for (let { module, missingRefs } of allMissingRefs) {
       if (isEmpty(missingRefs)) {
         continue;
       }
 
       print([{ bold: true, color: 'cyan', message: ` ${module}` }]);
-
+      
       const tableValues = Object.values(missingRefs).flat();
       missingRefs = Object.values(missingRefs).flat();
       const tableKeys = Object.keys(missingRefs[0]);
@@ -471,7 +528,7 @@ export abstract class AuditBaseCommand extends BaseCommand<typeof AuditBaseComma
         }));
 
       cliux.table(tableHeaders, tableValues, { ...(this.flags as TableFlags) });
-      this.log(''); // Adding a new line
+      cliux.print(''); // Adding a new line
     }
   }
 
@@ -493,19 +550,29 @@ export abstract class AuditBaseCommand extends BaseCommand<typeof AuditBaseComma
       | 'Summary',
     listOfMissingRefs: Record<string, any>,
   ): Promise<void> {
-    if (isEmpty(listOfMissingRefs)) return Promise.resolve(void 0);
+    log.debug(`Preparing report for module: ${moduleName}`, this.auditContext);
+    log.debug(`Report path: ${this.sharedConfig.reportPath}`, this.auditContext);
+    log.info(`Missing references count: ${Object.keys(listOfMissingRefs).length}`, this.auditContext);
+    
+    if (isEmpty(listOfMissingRefs)) {
+      log.debug(`No missing references found for ${moduleName}, skipping report generation`, this.auditContext);
+      return Promise.resolve(void 0);
+    }
 
     if (!existsSync(this.sharedConfig.reportPath)) {
+      log.debug(`Creating report directory: ${this.sharedConfig.reportPath}`, this.auditContext);
       mkdirSync(this.sharedConfig.reportPath, { recursive: true });
+    } else {
+      log.debug(`Report directory already exists: ${this.sharedConfig.reportPath}`, this.auditContext);
     }
 
     // NOTE write int json
-    writeFileSync(
-      join(sanitizePath(this.sharedConfig.reportPath), `${sanitizePath(moduleName)}.json`),
-      JSON.stringify(listOfMissingRefs),
-    );
+    const jsonFilePath = join(sanitizePath(this.sharedConfig.reportPath), `${sanitizePath(moduleName)}.json`);
+    log.debug(`Writing JSON report to: ${jsonFilePath}`, this.auditContext);
+    writeFileSync(jsonFilePath, JSON.stringify(listOfMissingRefs));
 
     // NOTE write into CSV
+    log.debug(`Preparing CSV report for: ${moduleName}`, this.auditContext);
     return this.prepareCSV(moduleName, listOfMissingRefs);
   }
 

packages/contentstack-audit/package.json

@@ -2,21 +2,16 @@ import merge from 'lodash/merge';
 import isEmpty from 'lodash/isEmpty';
 import { existsSync, readFileSync } from 'fs';
 import { Command } from '@contentstack/cli-command';
-import { Flags, FlagInput, Interfaces, cliux, ux, PrintOptions } from '@contentstack/cli-utilities';
+import { Flags, FlagInput, Interfaces, cliux, ux, handleAndLogError } from '@contentstack/cli-utilities';
 
 import config from './config';
-import { Logger } from './util';
-import { ConfigType, LogFn, LoggerType } from './types';
+import { ConfigType } from './types';
 import messages, { $t, commonMsg } from './messages';
 
 export type Args<T extends typeof Command> = Interfaces.InferredArgs<T['args']>;
 export type Flags<T extends typeof Command> = Interfaces.InferredFlags<(typeof BaseCommand)['baseFlags'] & T['flags']>;
 
-const noLog = (_message: string | any, _logType?: LoggerType | PrintOptions | undefined) => {};
-
 export abstract class BaseCommand<T extends typeof Command> extends Command {
-  public log!: LogFn;
-  public logger!: Logger;
   public readonly $t = $t;
   protected sharedConfig: ConfigType = {
     ...config,
@@ -71,12 +66,8 @@ export abstract class BaseCommand<T extends typeof Command> extends Command {
 
     // Init logger
     if (this.flags['external-config']?.noLog) {
-      this.log = noLog;
       ux.action.start = () => {};
       ux.action.stop = () => {};
-    } else {
-      const logger = new Logger(this.sharedConfig);
-      this.log = logger.log.bind(logger);
     }
   }
 
@@ -117,7 +108,7 @@ export abstract class BaseCommand<T extends typeof Command> extends Command {
           JSON.parse(readFileSync(this.flags.config, { encoding: 'utf-8' })),
         );
       } catch (error) {
-        this.log(error, 'error');
+        handleAndLogError(error);
       }
     }
   }

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

@@ -1,4 +1,4 @@
-import { FlagInput, Flags, ux } from '@contentstack/cli-utilities';
+import { FlagInput, Flags, ux, handleAndLogError } from '@contentstack/cli-utilities';
 
 import config from '../../../../config';
 import { ConfigType } from '../../../../types';
@@ -68,8 +68,7 @@ export default class AuditFix extends AuditBaseCommand {
         return { config: this.sharedConfig, hasFix };
       }
     } catch (error) {
-      this.log(error instanceof Error ? error.message : error, 'error');
-      console.trace(error);
+      handleAndLogError(error);
       ux.action.stop('Process failed.!');
       this.exit(1);
     }