@contentstack/cli-audit 1.0.0 → 1.2.0

package/lib/commands/cm/stacks/audit/index.d.ts

@@ -1,8 +1,6 @@
 import { FlagInput } from '@contentstack/cli-utilities';
-import config from '../../../../config';
-import { BaseCommand } from '../../../../base-command';
-import { ContentTypeStruct } from '../../../../types';
-export default class Audit extends BaseCommand<typeof Audit> {
+import { AuditBaseCommand } from '../../../../audit-base-command';
+export default class Audit extends AuditBaseCommand {
     static aliases: string[];
     static description: string;
     static examples: string[];
@@ -12,51 +10,4 @@ export default class Audit extends BaseCommand<typeof Audit> {
      * (content-types, global-fields, entries) and generates a report.
      */
     run(): Promise<void>;
-    /**
-     * The `promptQueue` function prompts the user to enter a data directory path if the `data-dir` flag
-     * is missing, and sets the `basePath` property of the `sharedConfig` object to the entered path.
-     */
-    promptQueue(): Promise<void>;
-    /**
-     * The function `getCtAndGfSchema` reads and parses JSON files containing content type and global
-     * field schemas, and returns them as an object.
-     * @returns The function `getCtAndGfSchema()` returns an object with two properties: `ctSchema` and
-     * `gfSchema`. The values of these properties are the parsed JSON data from two different files.
-     */
-    getCtAndGfSchema(): {
-        ctSchema: ContentTypeStruct[];
-        gfSchema: ContentTypeStruct[];
-    };
-    /**
-     * The function `showOutputOnScreen` displays missing references on the terminal screen if the
-     * `showTerminalOutput` flag is set to true.
-     * @param {{ module: string; missingRefs?: Record<string, any> }[]} allMissingRefs - An array of
-     * objects, where each object has two properties:
-     */
-    showOutputOnScreen(allMissingRefs: {
-        module: string;
-        missingRefs?: Record<string, any>;
-    }[]): void;
-    /**
-     * The function prepares a report by writing a JSON file and a CSV file with a list of missing
-     * references for a given module.
-     * @param moduleName - The `moduleName` parameter is a string that represents the name of a module.
-     * It is used to generate the filename for the report.
-     * @param listOfMissingRefs - The `listOfMissingRefs` parameter is a record object that contains
-     * information about missing references. It is a key-value pair where the key represents the
-     * reference name and the value represents additional information about the missing reference.
-     * @returns The function `prepareReport` returns a Promise that resolves to `void`.
-     */
-    prepareReport(moduleName: keyof typeof config.moduleConfig, listOfMissingRefs: Record<string, any>): Promise<void>;
-    /**
-     * The function `prepareCSV` takes a module name and a list of missing references, and generates a
-     * CSV file with the specified columns and filtered rows.
-     * @param moduleName - The `moduleName` parameter is a string that represents the name of a module.
-     * It is used to generate the name of the CSV file that will be created.
-     * @param listOfMissingRefs - The `listOfMissingRefs` parameter is a record object that contains
-     * information about missing references. Each key in the record represents a reference, and the
-     * corresponding value is an array of objects that contain details about the missing reference.
-     * @returns The function `prepareCSV` returns a Promise that resolves to `void`.
-     */
-    prepareCSV(moduleName: keyof typeof config.moduleConfig, listOfMissingRefs: Record<string, any>): Promise<void>;
 }

package/lib/commands/cm/stacks/audit/index.js

@@ -1,78 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-const chalk_1 = tslib_1.__importDefault(require("chalk"));
-const csv = tslib_1.__importStar(require("fast-csv"));
-const isEmpty_1 = tslib_1.__importDefault(require("lodash/isEmpty"));
-const path_1 = require("path");
 const cli_utilities_1 = require("@contentstack/cli-utilities");
-const fs_1 = require("fs");
 const config_1 = tslib_1.__importDefault(require("../../../../config"));
-const log_1 = require("../../../../util/log");
 const messages_1 = require("../../../../messages");
-const base_command_1 = require("../../../../base-command");
-const modules_1 = require("../../../../modules");
-const types_1 = require("../../../../types");
-class Audit extends base_command_1.BaseCommand {
+const audit_base_command_1 = require("../../../../audit-base-command");
+class Audit extends audit_base_command_1.AuditBaseCommand {
     /**
      * The `run` function is an asynchronous function that performs an audit on different modules
      * (content-types, global-fields, entries) and generates a report.
      */
     async run() {
         try {
-            await this.promptQueue();
-            const reportPath = this.flags['report-path'] || process.cwd();
-            this.sharedConfig.reportPath = (0, path_1.resolve)(reportPath, 'audit-report');
-            let { ctSchema, gfSchema } = this.getCtAndGfSchema();
-            let missingCtRefs, missingGfRefs, missingEntryRefs;
-            for (const module of this.sharedConfig.flags.modules || this.sharedConfig.modules) {
-                cli_utilities_1.ux.action.start(this.$t(this.messages.AUDIT_START_SPINNER, { module }));
-                switch (module) {
-                    case 'content-types':
-                        missingCtRefs = await new modules_1.ContentType({
-                            ctSchema,
-                            gfSchema,
-                            log: this.log,
-                            moduleName: module,
-                            config: this.sharedConfig,
-                        }).run();
-                        await this.prepareReport(module, missingCtRefs);
-                        break;
-                    case 'global-fields':
-                        missingGfRefs = await new modules_1.GlobalField({
-                            ctSchema,
-                            gfSchema,
-                            log: this.log,
-                            moduleName: module,
-                            config: this.sharedConfig,
-                        }).run();
-                        await this.prepareReport(module, missingGfRefs);
-                        break;
-                    case 'entries':
-                        missingEntryRefs = await new modules_1.Entries({
-                            ctSchema,
-                            gfSchema,
-                            log: this.log,
-                            moduleName: module,
-                            config: this.sharedConfig,
-                        }).run();
-                        await this.prepareReport(module, missingEntryRefs);
-                        break;
-                }
-                cli_utilities_1.ux.action.stop();
-            }
-            this.showOutputOnScreen([
-                { module: 'Content types', missingRefs: missingCtRefs },
-                { module: 'Global Fields', missingRefs: missingGfRefs },
-                { module: 'Entries', missingRefs: missingEntryRefs },
-            ]);
-            if (!(0, isEmpty_1.default)(missingCtRefs) || !(0, isEmpty_1.default)(missingGfRefs) || !(0, isEmpty_1.default)(missingEntryRefs)) {
-                this.log(this.$t(messages_1.auditMsg.FINAL_REPORT_PATH, { path: this.sharedConfig.reportPath }), 'warn');
-            }
-            else {
-                this.log(this.messages.NO_MISSING_REF_FOUND, 'info');
-                this.log('');
-            }
+            await this.start('cm:stacks:audit');
         }
         catch (error) {
             this.log(error instanceof Error ? error.message : error, 'error');
@@ -81,146 +21,10 @@ class Audit extends base_command_1.BaseCommand {
             this.exit(1);
         }
     }
-    /**
-     * The `promptQueue` function prompts the user to enter a data directory path if the `data-dir` flag
-     * is missing, and sets the `basePath` property of the `sharedConfig` object to the entered path.
-     */
-    async promptQueue() {
-        // NOTE get content path if data-dir flag is missing
-        this.sharedConfig.basePath =
-            this.flags['data-dir'] ||
-                (await cli_utilities_1.cliux.inquire({
-                    type: 'input',
-                    name: 'data-dir',
-                    message: this.messages.DATA_DIR,
-                }));
-    }
-    /**
-     * The function `getCtAndGfSchema` reads and parses JSON files containing content type and global
-     * field schemas, and returns them as an object.
-     * @returns The function `getCtAndGfSchema()` returns an object with two properties: `ctSchema` and
-     * `gfSchema`. The values of these properties are the parsed JSON data from two different files.
-     */
-    getCtAndGfSchema() {
-        const ctPath = (0, path_1.join)(this.sharedConfig.basePath, this.sharedConfig.moduleConfig['content-types'].dirName, this.sharedConfig.moduleConfig['content-types'].fileName);
-        const gfPath = (0, path_1.join)(this.sharedConfig.basePath, this.sharedConfig.moduleConfig['global-fields'].dirName, this.sharedConfig.moduleConfig['global-fields'].fileName);
-        let ctSchema = (0, fs_1.existsSync)(ctPath) ? JSON.parse((0, fs_1.readFileSync)(ctPath, 'utf-8')) : [];
-        let gfSchema = (0, fs_1.existsSync)(gfPath) ? JSON.parse((0, fs_1.readFileSync)(gfPath, 'utf-8')) : [];
-        return { ctSchema, gfSchema };
-    }
-    /**
-     * The function `showOutputOnScreen` displays missing references on the terminal screen if the
-     * `showTerminalOutput` flag is set to true.
-     * @param {{ module: string; missingRefs?: Record<string, any> }[]} allMissingRefs - An array of
-     * objects, where each object has two properties:
-     */
-    showOutputOnScreen(allMissingRefs) {
-        if (this.sharedConfig.showTerminalOutput) {
-            this.log(''); // NOTE adding new line
-            for (const { module, missingRefs } of allMissingRefs) {
-                if (!(0, isEmpty_1.default)(missingRefs)) {
-                    (0, log_1.print)([
-                        {
-                            bold: true,
-                            color: 'cyan',
-                            message: ` ${module}`,
-                        },
-                    ]);
-                    cli_utilities_1.ux.table(Object.values(missingRefs).flat(), {
-                        name: {
-                            minWidth: 7,
-                            header: 'Title',
-                        },
-                        display_name: {
-                            minWidth: 7,
-                            header: 'Field name',
-                        },
-                        data_type: {
-                            minWidth: 7,
-                            header: 'Field type',
-                        },
-                        missingRefs: {
-                            minWidth: 7,
-                            header: 'Missing references',
-                            get: (row) => {
-                                return chalk_1.default.red(typeof row.missingRefs === 'object' ? JSON.stringify(row.missingRefs) : row.missingRefs);
-                            },
-                        },
-                        treeStr: {
-                            minWidth: 7,
-                            header: 'Path',
-                        },
-                    }, Object.assign({}, this.flags));
-                    this.log(''); // NOTE adding new line
-                }
-            }
-        }
-    }
-    /**
-     * The function prepares a report by writing a JSON file and a CSV file with a list of missing
-     * references for a given module.
-     * @param moduleName - The `moduleName` parameter is a string that represents the name of a module.
-     * It is used to generate the filename for the report.
-     * @param listOfMissingRefs - The `listOfMissingRefs` parameter is a record object that contains
-     * information about missing references. It is a key-value pair where the key represents the
-     * reference name and the value represents additional information about the missing reference.
-     * @returns The function `prepareReport` returns a Promise that resolves to `void`.
-     */
-    prepareReport(moduleName, listOfMissingRefs) {
-        if ((0, isEmpty_1.default)(listOfMissingRefs))
-            return Promise.resolve(void 0);
-        if (!(0, fs_1.existsSync)(this.sharedConfig.reportPath)) {
-            (0, fs_1.mkdirSync)(this.sharedConfig.reportPath, { recursive: true });
-        }
-        // NOTE write int json
-        (0, fs_1.writeFileSync)((0, path_1.join)(this.sharedConfig.reportPath, `${moduleName}.json`), JSON.stringify(listOfMissingRefs));
-        // NOTE write into CSV
-        return this.prepareCSV(moduleName, listOfMissingRefs);
-    }
-    /**
-     * The function `prepareCSV` takes a module name and a list of missing references, and generates a
-     * CSV file with the specified columns and filtered rows.
-     * @param moduleName - The `moduleName` parameter is a string that represents the name of a module.
-     * It is used to generate the name of the CSV file that will be created.
-     * @param listOfMissingRefs - The `listOfMissingRefs` parameter is a record object that contains
-     * information about missing references. Each key in the record represents a reference, and the
-     * corresponding value is an array of objects that contain details about the missing reference.
-     * @returns The function `prepareCSV` returns a Promise that resolves to `void`.
-     */
-    prepareCSV(moduleName, listOfMissingRefs) {
-        const csvStream = csv.format({ headers: true });
-        const csvPath = (0, path_1.join)(this.sharedConfig.reportPath, `${moduleName}.csv`);
-        const assetFileStream = (0, fs_1.createWriteStream)(csvPath);
-        assetFileStream.on('error', (error) => {
-            throw error;
-        });
-        return new Promise((resolve, reject) => {
-            csvStream.pipe(assetFileStream).on('close', resolve).on('error', reject);
-            const defaultColumns = Object.keys(types_1.OutputColumn);
-            const userDefinedColumns = this.sharedConfig.flags.columns ? this.sharedConfig.flags.columns.split(',') : null;
-            let missingRefs = Object.values(listOfMissingRefs).flat();
-            const columns = userDefinedColumns
-                ? [...userDefinedColumns, ...defaultColumns.filter((val) => !userDefinedColumns.includes(val))]
-                : defaultColumns;
-            if (this.sharedConfig.flags.filter) {
-                const [column, value] = this.sharedConfig.flags.filter.split('=');
-                missingRefs = missingRefs.filter((row) => row[types_1.OutputColumn[column]] === value);
-            }
-            for (const issue of missingRefs) {
-                let row = {};
-                for (const column of columns) {
-                    row[column] = issue[types_1.OutputColumn[column]];
-                    row[column] = typeof row[column] === 'object' ? JSON.stringify(row[column]) : row[column];
-                }
-                csvStream.write(row);
-            }
-            csvStream.end();
-        });
-    }
 }
 exports.default = Audit;
-Audit.aliases = ['cm:stacks:audit'];
-Audit.description = 'Perform audits and find possible errors in the exported Contentstack data';
+Audit.aliases = ['audit', 'cm:stacks:audit'];
+Audit.description = messages_1.auditMsg.AUDIT_CMD_DESCRIPTION;
 Audit.examples = [
     '$ <%= config.bin %> <%= command.id %>',
     '$ <%= config.bin %> <%= command.id %> --report-path=<path>',

package/lib/messages/index.d.ts

@@ -1,10 +1,8 @@
-declare const errors: {
-    NOT_EMPTY: string;
-};
+declare const errors: {};
 declare const commonMsg: {
     CONFIG: string;
-    CURRENT_WORKING_DIR: string;
     DATA_DIR: string;
+    FIX_CONFIRMATION: string;
 };
 declare const auditMsg: {
     REPORT_PATH: string;
@@ -17,8 +15,16 @@ declare const auditMsg: {
     FINAL_REPORT_PATH: string;
     SCAN_CT_SUCCESS_MSG: string;
     SCAN_ENTRY_SUCCESS_MSG: string;
+    AUDIT_CMD_DESCRIPTION: string;
+};
+declare const auditFixMsg: {
+    COPY_DATA: string;
+    BKP_PATH: string;
+    FIXED_CONTENT_PATH_MAG: string;
+    EMPTY_FIX_MSG: string;
+    AUDIT_FIX_CMD_DESCRIPTION: string;
 };
-declare const messages: typeof errors & typeof commonMsg & typeof auditMsg;
+declare const messages: typeof errors & typeof commonMsg & typeof auditMsg & typeof auditFixMsg;
 /**
  * The function `$t` is a TypeScript function that replaces placeholders in a string with corresponding
  * values from an object.
@@ -30,4 +36,4 @@ declare const messages: typeof errors & typeof commonMsg & typeof auditMsg;
  */
 declare function $t(msg: string, args: Record<string, string>): string;
 export default messages;
-export { $t, errors, commonMsg, auditMsg };
+export { $t, errors, commonMsg, auditMsg, auditFixMsg };

package/lib/messages/index.js

@@ -1,19 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.auditMsg = exports.commonMsg = exports.errors = exports.$t = void 0;
-const errors = {
-    NOT_EMPTY: '{value} cannot be empty.',
-};
+exports.auditFixMsg = exports.auditMsg = exports.commonMsg = exports.errors = exports.$t = void 0;
+const errors = {};
 exports.errors = errors;
 const commonMsg = {
-    CONFIG: 'Path of the external config.',
-    CURRENT_WORKING_DIR: 'Current working directory.',
-    DATA_DIR: 'Path where the data is stored.',
+    CONFIG: 'Path of the external config',
+    DATA_DIR: 'Path where the data is stored',
+    FIX_CONFIRMATION: 'Would you like to overwrite existing file.?',
 };
 exports.commonMsg = commonMsg;
 const auditMsg = {
-    REPORT_PATH: 'Path to store the audit reports.',
-    MODULES: 'Provide the list of modules to be audited.',
+    REPORT_PATH: 'Path to store the audit reports',
+    MODULES: 'Provide the list of modules to be audited',
     AUDIT_START_SPINNER: '{module} scanning...',
     PREPARING_ENTRY_METADATA: 'Creating entry metadata...',
     REFERENCE_ONLY: 'Checks only for missing references.',
@@ -22,9 +20,18 @@ const auditMsg = {
     FINAL_REPORT_PATH: "Reports ready. Please find the reports at '{path}'.",
     SCAN_CT_SUCCESS_MSG: "Successfully completed the scanning of {module} '{title}'.",
     SCAN_ENTRY_SUCCESS_MSG: "Successfully completed the scanning of {module} ({local}) '{title}'.",
+    AUDIT_CMD_DESCRIPTION: 'Perform audits and find possible errors in the exported Contentstack data',
 };
 exports.auditMsg = auditMsg;
-const messages = Object.assign(Object.assign(Object.assign({}, errors), commonMsg), auditMsg);
+const auditFixMsg = {
+    COPY_DATA: 'Create backup from the original data.',
+    BKP_PATH: 'Provide the path to backup the copied data',
+    FIXED_CONTENT_PATH_MAG: 'You can locate the fixed content at {path}.',
+    EMPTY_FIX_MSG: 'Successfully removed the empty field/block found at {path} from the schema.',
+    AUDIT_FIX_CMD_DESCRIPTION: 'Perform audits and fix possible errors in the exported Contentstack data.',
+};
+exports.auditFixMsg = auditFixMsg;
+const messages = Object.assign(Object.assign(Object.assign(Object.assign({}, errors), commonMsg), auditMsg), auditFixMsg);
 /**
  * The function `$t` is a TypeScript function that replaces placeholders in a string with corresponding
  * values from an object.

package/lib/modules/content-types.d.ts

@@ -1,7 +1,8 @@
-import { LogFn, ConfigType, ModularBlockType, ContentTypeStruct, GroupFieldDataType, RefErrorReturnType, CtConstructorParam, GlobalFieldDataType, JsonRTEFieldDataType, ModularBlocksDataType, ModuleConstructorParam, ReferenceFieldDataType } from '../types';
+import { LogFn, ConfigType, ModularBlockType, ContentTypeStruct, GroupFieldDataType, RefErrorReturnType, CtConstructorParam, GlobalFieldDataType, JsonRTEFieldDataType, ModularBlocksDataType, ModuleConstructorParam, ReferenceFieldDataType, ContentTypeSchemaType } from '../types';
 import auditConfig from '../config';
 export default class ContentType {
     log: LogFn;
+    protected fix: boolean;
     fileName: string;
     config: ConfigType;
     folderPath: string;
@@ -12,13 +13,18 @@ export default class ContentType {
     protected schema: ContentTypeStruct[];
     protected missingRefs: Record<string, any>;
     moduleName: keyof typeof auditConfig.moduleConfig;
-    constructor({ log, config, moduleName, ctSchema, gfSchema }: ModuleConstructorParam & CtConstructorParam);
+    constructor({ log, fix, config, moduleName, ctSchema, gfSchema }: ModuleConstructorParam & CtConstructorParam);
     /**
      * The `run` function checks if a folder path exists, sets the schema based on the module name,
      * iterates over the schema and looks for references, and returns a list of missing references.
      * @returns the `missingRefs` object.
      */
-    run(): Promise<Record<string, any>>;
+    run(returnFixSchema?: boolean): Promise<Record<string, any>>;
+    /**
+     * The function checks if it can write the fix content to a file and if so, it writes the content as
+     * JSON to the specified file path.
+     */
+    writeFixContent(): Promise<void>;
     /**
      * The function `lookForReference` iterates through a given schema and performs validation checks
      * based on the data type of each field.
@@ -30,7 +36,7 @@ export default class ContentType {
      * `tree`: An array of objects representing the tree structure of the content type or field. Each
      * object in the array should have a `uid` and `name` property.
      */
-    lookForReference(tree: Record<string, unknown>[], { schema }: ContentTypeStruct | GlobalFieldDataType | ModularBlockType | GroupFieldDataType): Promise<void>;
+    lookForReference(tree: Record<string, unknown>[], field: ContentTypeStruct | GlobalFieldDataType | ModularBlockType | GroupFieldDataType): Promise<void>;
     /**
      * The function validates a reference field in a tree data structure.
      * @param {Record<string, unknown>[]} tree - The "tree" parameter is an array of objects, where each
@@ -93,4 +99,53 @@ export default class ContentType {
      * objects.
      */
     validateReferenceToValues(tree: Record<string, unknown>[], field: ReferenceFieldDataType | JsonRTEFieldDataType): RefErrorReturnType[];
+    /**
+     * The function `runFixOnSchema` takes in a tree and a schema, and performs various fixes on the
+     * schema based on the data types of the fields.
+     * @param {Record<string, unknown>[]} tree - An array of objects representing the tree structure of
+     * the schema.
+     * @param {ContentTypeSchemaType[]} schema - The `schema` parameter is an array of
+     * `ContentTypeSchemaType` objects. Each object represents a field in a content type schema and
+     * contains properties such as `data_type`, `field_metadata`, `uid`, `name`, etc.
+     * @returns an array of ContentTypeSchemaType objects.
+     */
+    runFixOnSchema(tree: Record<string, unknown>[], schema: ContentTypeSchemaType[]): ContentTypeSchemaType[];
+    /**
+     * The function fixes global field references in a tree structure by adding missing references and
+     * returning the field if the reference exists, otherwise returning null.
+     * @param {Record<string, unknown>[]} tree - An array of objects representing a tree structure.
+     * @param {GlobalFieldDataType} field - The `field` parameter is an object that represents a global
+     * field. It has the following properties:
+     * @returns either the `field` object if `reference_to` exists in `this.gfSchema`, or `null` if it
+     * doesn't.
+     */
+    fixGlobalFieldReferences(tree: Record<string, unknown>[], field: GlobalFieldDataType): GlobalFieldDataType | null;
+    /**
+     * The function `fixModularBlocksReferences` takes in an array of tree objects and an array of
+     * modular blocks, and returns an array of modular blocks with fixed references.
+     * @param {Record<string, unknown>[]} tree - An array of objects representing the tree structure.
+     * @param {ModularBlockType[]} blocks - An array of objects representing modular blocks. Each object
+     * has properties such as "reference_to", "schema", "title", and "uid".
+     * @returns an array of `ModularBlockType` objects.
+     */
+    fixModularBlocksReferences(tree: Record<string, unknown>[], blocks: ModularBlockType[]): ModularBlockType[];
+    /**
+     * The function `fixMissingReferences` checks for missing references in a given tree and field, and
+     * attempts to fix them by removing the missing references from the field's `reference_to` array.
+     * @param {Record<string, unknown>[]} tree - An array of objects representing a tree structure. Each
+     * object in the array should have a "name" property.
+     * @param {ReferenceFieldDataType | JsonRTEFieldDataType} field - The `field` parameter is of type
+     * `ReferenceFieldDataType` or `JsonRTEFieldDataType`.
+     * @returns the `field` object.
+     */
+    fixMissingReferences(tree: Record<string, unknown>[], field: ReferenceFieldDataType | JsonRTEFieldDataType): ReferenceFieldDataType | JsonRTEFieldDataType;
+    /**
+     * The function `fixGroupField` takes in an array of objects and a field, and performs some
+     * operations on the field's schema property.
+     * @param {Record<string, unknown>[]} tree - An array of objects representing a tree structure.
+     * @param {GroupFieldDataType} field - The `field` parameter is an object that contains the following
+     * properties:
+     * @returns The function `fixGroupField` returns either `null` or the `field` object.
+     */
+    fixGroupField(tree: Record<string, unknown>[], field: GroupFieldDataType): GroupFieldDataType | null;
 }