@contentstack/cli-audit 1.10.0 → 1.12.0

package/lib/modules/entries.js

@@ -67,6 +67,7 @@ class Entries {
                         const { uid, title } = entry;
                         this.currentUid = uid;
                         this.currentTitle = title;
+                        this.currentTitle = this.removeEmojiAndImages(this.currentTitle);
                         if (!this.missingRefs[this.currentUid]) {
                             this.missingRefs[this.currentUid] = [];
                         }
@@ -79,7 +80,7 @@ class Entries {
                         if (this.fix) {
                             this.removeMissingKeysOnEntry(ctSchema.schema, this.entries[entryUid]);
                         }
-                        this.lookForReference([{ locale: code, uid, name: title }], ctSchema, this.entries[entryUid]);
+                        this.lookForReference([{ locale: code, uid, name: this.removeEmojiAndImages(title) }], ctSchema, this.entries[entryUid]);
                         if ((_a = this.missingRefs[this.currentUid]) === null || _a === void 0 ? void 0 : _a.length) {
                             this.missingRefs[this.currentUid].forEach((entry) => {
                                 entry.ct = ctSchema.uid;
@@ -251,7 +252,7 @@ class Entries {
         let canWrite = true;
         if (this.fix) {
             if (!this.config.flags['copy-dir'] && !((_a = this.config.flags['external-config']) === null || _a === void 0 ? void 0 : _a.skipConfirm)) {
-                canWrite = this.config.flags.yes || (await cli_utilities_1.ux.confirm(messages_1.commonMsg.FIX_CONFIRMATION));
+                canWrite = this.config.flags.yes || (await cli_utilities_1.cliux.confirm(messages_1.commonMsg.FIX_CONFIRMATION));
             }
             if (canWrite) {
                 (0, fs_1.writeFileSync)(filePath, JSON.stringify(schema));
@@ -641,6 +642,9 @@ class Entries {
      * @returns if there is missing field returns field and path
      * Else empty array
      */
+    removeEmojiAndImages(str) {
+        return str.replace(/[\p{Emoji}\p{Emoji_Presentation}\p{Emoji_Modifier}\p{Emoji_Modifier_Base}\p{Emoji_Component}]+/gu, '');
+    }
     validateSelectField(tree, fieldStructure, field) {
         const { display_name, enum: selectOptions, multiple, min_instance, display_type, data_type } = fieldStructure;
         if (field === null ||

package/lib/modules/extensions.js

@@ -74,7 +74,7 @@ class Extensions {
             }
             else {
                 this.log((0, messages_1.$t)(messages_1.commonMsg.EXTENSION_FIX_WARN, { title: title, uid }), { color: 'yellow' });
-                const shouldDelete = this.config.flags.yes || (await cli_utilities_1.ux.confirm(messages_1.commonMsg.EXTENSION_FIX_CONFIRMATION));
+                const shouldDelete = this.config.flags.yes || (await cli_utilities_1.cliux.confirm(messages_1.commonMsg.EXTENSION_FIX_CONFIRMATION));
                 if (shouldDelete) {
                     delete newExtensionSchema[uid];
                 }
@@ -88,7 +88,7 @@ class Extensions {
             (this.config.flags['copy-dir'] ||
                 ((_a = this.config.flags['external-config']) === null || _a === void 0 ? void 0 : _a.skipConfirm) ||
                 this.config.flags.yes ||
-                (await cli_utilities_1.ux.confirm(messages_1.commonMsg.FIX_CONFIRMATION)))) {
+                (await cli_utilities_1.cliux.confirm(messages_1.commonMsg.FIX_CONFIRMATION)))) {
             (0, fs_1.writeFileSync)((0, path_1.join)(this.folderPath, this.config.moduleConfig[this.moduleName].fileName), JSON.stringify(fixedExtensions));
         }
     }

package/lib/modules/field_rules.d.ts

@@ -0,0 +1,54 @@
+import { Locale } from '@contentstack/cli-utilities';
+import { LogFn, ConfigType, ModularBlockType, ContentTypeStruct, GroupFieldDataType, CtConstructorParam, GlobalFieldDataType, ModularBlocksDataType, ModuleConstructorParam, EntryStruct } from '../types';
+import auditConfig from '../config';
+export default class FieldRule {
+    log: LogFn;
+    protected fix: boolean;
+    fileName: string;
+    config: ConfigType;
+    folderPath: string;
+    currentUid: string;
+    currentTitle: string;
+    extensions: string[];
+    inMemoryFix: boolean;
+    gfSchema: ContentTypeStruct[];
+    ctSchema: ContentTypeStruct[];
+    protected schema: ContentTypeStruct[];
+    protected missingRefs: Record<string, any>;
+    moduleName: keyof typeof auditConfig.moduleConfig;
+    schemaMap: any;
+    locales: Locale[];
+    protected entries: Record<string, EntryStruct>;
+    protected missingSelectFeild: Record<string, any>;
+    protected missingMandatoryFields: Record<string, any>;
+    protected missingEnvLocale: Record<string, any>;
+    entryMetaData: Record<string, any>[];
+    action: string[];
+    constructor({ log, fix, config, moduleName, ctSchema, gfSchema }: ModuleConstructorParam & CtConstructorParam);
+    validateModules(moduleName: keyof typeof auditConfig.moduleConfig, moduleConfig: Record<string, unknown>): keyof typeof auditConfig.moduleConfig;
+    /**
+     * 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>>;
+    validateFieldRules(schema: Record<string, unknown>): void;
+    fixFieldRules(schema: Record<string, unknown>): void;
+    addMissingReferences(actions: Record<string, unknown>, fixStatus?: string): void;
+    /**
+     * @method prerequisiteData
+     * The `prerequisiteData` function reads and parses JSON files to retrieve extension and marketplace
+     * app data, and stores them in the `extensions` array.
+     */
+    prerequisiteData(): Promise<void>;
+    /**
+     * 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>;
+    lookForReference(tree: Record<string, unknown>[], field: ContentTypeStruct | GlobalFieldDataType | ModularBlockType | GroupFieldDataType, parent?: string | null): Promise<void>;
+    validateGlobalField(tree: Record<string, unknown>[], field: GlobalFieldDataType, parent: string | null): Promise<void>;
+    validateModularBlocksField(tree: Record<string, unknown>[], field: ModularBlocksDataType, parent: string | null): Promise<void>;
+    validateGroupField(tree: Record<string, unknown>[], field: GroupFieldDataType, parent: string | null): Promise<void>;
+    prepareEntryMetaData(): Promise<void>;
+}

package/lib/modules/field_rules.js

@@ -0,0 +1,265 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const map_1 = tslib_1.__importDefault(require("lodash/map"));
+const path_1 = require("path");
+const fs_1 = require("fs");
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+const messages_1 = require("../messages");
+const lodash_1 = require("lodash");
+/* The `ContentType` class is responsible for scanning content types, looking for references, and
+generating a report in JSON and CSV formats. */
+class FieldRule {
+    constructor({ log, fix, config, moduleName, ctSchema, gfSchema }) {
+        this.extensions = [];
+        this.inMemoryFix = false;
+        this.schema = [];
+        this.missingRefs = {};
+        this.schemaMap = [];
+        this.missingSelectFeild = {};
+        this.missingMandatoryFields = {};
+        this.missingEnvLocale = {};
+        this.entryMetaData = [];
+        this.action = ['show', 'hide'];
+        this.log = log;
+        this.config = config;
+        this.fix = fix !== null && fix !== void 0 ? fix : false;
+        this.ctSchema = ctSchema;
+        this.gfSchema = gfSchema;
+        this.moduleName = this.validateModules(moduleName, this.config.moduleConfig);
+        this.fileName = config.moduleConfig[this.moduleName].fileName;
+        this.folderPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(config.basePath), (0, cli_utilities_1.sanitizePath)(config.moduleConfig[this.moduleName].dirName));
+    }
+    validateModules(moduleName, moduleConfig) {
+        if (Object.keys(moduleConfig).includes(moduleName)) {
+            return moduleName;
+        }
+        return 'content-types';
+    }
+    /**
+     * 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.
+     */
+    async run() {
+        var _a;
+        if (!(0, fs_1.existsSync)(this.folderPath)) {
+            this.log(`Skipping ${this.moduleName} audit`, 'warn');
+            this.log((0, messages_1.$t)(messages_1.auditMsg.NOT_VALID_PATH, { path: this.folderPath }), { color: 'yellow' });
+            return {};
+        }
+        this.schema = this.moduleName === 'content-types' ? this.ctSchema : this.gfSchema;
+        await this.prerequisiteData();
+        await this.prepareEntryMetaData();
+        for (const schema of (_a = this.schema) !== null && _a !== void 0 ? _a : []) {
+            this.currentUid = schema.uid;
+            this.currentTitle = schema.title;
+            this.missingRefs[this.currentUid] = [];
+            const { uid, title } = schema;
+            await this.lookForReference([{ uid, name: title }], schema, null);
+            this.missingRefs[this.currentUid] = [];
+            if (this.fix) {
+                this.fixFieldRules(schema);
+            }
+            else {
+                this.validateFieldRules(schema);
+            }
+            this.schemaMap = [];
+            this.log((0, messages_1.$t)(messages_1.auditMsg.SCAN_CT_SUCCESS_MSG, { title, module: this.config.moduleConfig[this.moduleName].name }), 'info');
+        }
+        if (this.fix) {
+            await this.writeFixContent();
+        }
+        for (let propName in this.missingRefs) {
+            if (!this.missingRefs[propName].length) {
+                delete this.missingRefs[propName];
+            }
+        }
+        return this.missingRefs;
+    }
+    validateFieldRules(schema) {
+        if (Array.isArray(schema.field_rules)) {
+            let count = 0;
+            schema.field_rules.forEach((fr) => {
+                fr.actions.forEach((actions) => {
+                    if (!this.schemaMap.includes(actions.target_field)) {
+                        this.log((0, messages_1.$t)(messages_1.auditMsg.FIELD_RULE_TARGET_ABSENT, {
+                            target_field: actions.target_field,
+                            ctUid: schema.uid,
+                        }), 'error');
+                        this.addMissingReferences(actions);
+                    }
+                    this.log((0, messages_1.$t)(messages_1.auditMsg.FIELD_RULE_TARGET_SCAN_MESSAGE, { num: count.toString(), ctUid: schema.uid }), 'info');
+                });
+                fr.conditions.forEach((actions) => {
+                    if (!this.schemaMap.includes(actions.operand_field)) {
+                        this.addMissingReferences(actions);
+                        this.log((0, messages_1.$t)(messages_1.auditMsg.FIELD_RULE_CONDITION_ABSENT, { condition_field: actions.operand_field }), 'error');
+                    }
+                    this.log((0, messages_1.$t)(messages_1.auditMsg.FIELD_RULE_CONDITION_SCAN_MESSAGE, { num: count.toString(), ctUid: schema.uid }), 'info');
+                });
+                count = count + 1;
+            });
+        }
+    }
+    fixFieldRules(schema) {
+        if (!Array.isArray(schema.field_rules))
+            return;
+        schema.field_rules = schema.field_rules
+            .map((fr, index) => {
+            var _a, _b, _c, _d;
+            const validActions = (_b = (_a = fr.actions) === null || _a === void 0 ? void 0 : _a.filter(action => {
+                const isValid = this.schemaMap.includes(action.target_field);
+                const logMsg = isValid
+                    ? messages_1.auditMsg.FIELD_RULE_TARGET_SCAN_MESSAGE
+                    : messages_1.auditMsg.FIELD_RULE_TARGET_ABSENT;
+                this.log((0, messages_1.$t)(logMsg, Object.assign({ num: index.toString(), ctUid: schema.uid }, (action.target_field && { target_field: action.target_field }))), isValid ? 'info' : 'error');
+                if (!isValid) {
+                    this.addMissingReferences(action, 'Fixed');
+                    this.log((0, messages_1.$t)(messages_1.auditFixMsg.FIELD_RULE_FIX_MESSAGE, {
+                        num: index.toString(),
+                        ctUid: schema.uid
+                    }), 'info');
+                }
+                return isValid;
+            })) !== null && _b !== void 0 ? _b : [];
+            const validConditions = (_d = (_c = fr.conditions) === null || _c === void 0 ? void 0 : _c.filter(condition => {
+                const isValid = this.schemaMap.includes(condition.operand_field);
+                const logMsg = isValid
+                    ? messages_1.auditMsg.FIELD_RULE_CONDITION_SCAN_MESSAGE
+                    : messages_1.auditMsg.FIELD_RULE_CONDITION_ABSENT;
+                this.log((0, messages_1.$t)(logMsg, Object.assign({ num: index.toString(), ctUid: schema.uid }, (condition.operand_field && { condition_field: condition.operand_field }))), isValid ? 'info' : 'error');
+                if (!isValid) {
+                    this.addMissingReferences(condition, 'Fixed');
+                    this.log((0, messages_1.$t)(messages_1.auditFixMsg.FIELD_RULE_FIX_MESSAGE, {
+                        num: index.toString(),
+                        ctUid: schema.uid
+                    }), 'info');
+                }
+                return isValid;
+            })) !== null && _d !== void 0 ? _d : [];
+            return (validActions.length && validConditions.length) ? Object.assign(Object.assign({}, fr), { actions: validActions, conditions: validConditions }) : null;
+        })
+            .filter(Boolean);
+    }
+    addMissingReferences(actions, fixStatus) {
+        if (fixStatus) {
+            this.missingRefs[this.currentUid].push({
+                ctUid: this.currentUid,
+                action: actions,
+                fixStatus: 'Fixed',
+            });
+        }
+        else {
+            this.missingRefs[this.currentUid].push({ ctUid: this.currentUid, action: actions });
+        }
+    }
+    /**
+     * @method prerequisiteData
+     * The `prerequisiteData` function reads and parses JSON files to retrieve extension and marketplace
+     * app data, and stores them in the `extensions` array.
+     */
+    async prerequisiteData() {
+        var _a;
+        const extensionPath = (0, path_1.resolve)(this.config.basePath, 'extensions', 'extensions.json');
+        const marketplacePath = (0, path_1.resolve)(this.config.basePath, 'marketplace_apps', 'marketplace_apps.json');
+        if ((0, fs_1.existsSync)(extensionPath)) {
+            try {
+                this.extensions = Object.keys(JSON.parse((0, fs_1.readFileSync)(extensionPath, 'utf8')));
+            }
+            catch (error) { }
+        }
+        if ((0, fs_1.existsSync)(marketplacePath)) {
+            try {
+                const marketplaceApps = JSON.parse((0, fs_1.readFileSync)(marketplacePath, 'utf8'));
+                for (const app of marketplaceApps) {
+                    const metaData = (0, map_1.default)((0, map_1.default)((_a = app === null || app === void 0 ? void 0 : app.ui_location) === null || _a === void 0 ? void 0 : _a.locations, 'meta').flat(), 'extension_uid').filter((val) => val);
+                    this.extensions.push(...metaData);
+                }
+            }
+            catch (error) { }
+        }
+    }
+    /**
+     * 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.
+     */
+    async writeFixContent() {
+        var _a, _b;
+        let canWrite = true;
+        if (this.fix) {
+            if (!this.config.flags['copy-dir'] && !((_a = this.config.flags['external-config']) === null || _a === void 0 ? void 0 : _a.skipConfirm)) {
+                canWrite = (_b = this.config.flags.yes) !== null && _b !== void 0 ? _b : (await cli_utilities_1.cliux.confirm(messages_1.commonMsg.FIX_CONFIRMATION));
+            }
+            if (canWrite) {
+                (0, fs_1.writeFileSync)((0, path_1.join)(this.folderPath, this.config.moduleConfig[this.moduleName].fileName), JSON.stringify(this.schema));
+            }
+        }
+    }
+    async lookForReference(tree, field, parent = null) {
+        var _a, _b;
+        const fixTypes = (_a = this.config.flags['fix-only']) !== null && _a !== void 0 ? _a : this.config['fix-fields'];
+        for (let child of (_b = field.schema) !== null && _b !== void 0 ? _b : []) {
+            if (parent !== null) {
+                this.schemaMap.push(`${parent}.${child === null || child === void 0 ? void 0 : child.uid}`);
+            }
+            else {
+                this.schemaMap.push(child.uid);
+            }
+            if (!fixTypes.includes(child.data_type) && child.data_type !== 'json')
+                continue;
+            switch (child.data_type) {
+                case 'global_field':
+                    await this.validateGlobalField([...tree, { uid: child.uid, name: child.display_name }], child, parent ? `${parent}.${child === null || child === void 0 ? void 0 : child.uid}` : child === null || child === void 0 ? void 0 : child.uid);
+                    break;
+                case 'blocks':
+                    await this.validateModularBlocksField([...tree, { uid: child.uid, name: child.display_name }], child, parent ? `${parent}.${child === null || child === void 0 ? void 0 : child.uid}` : child === null || child === void 0 ? void 0 : child.uid);
+                    break;
+                case 'group':
+                    await this.validateGroupField([...tree, { uid: child.uid, name: child.display_name }], child, parent ? `${parent}.${child === null || child === void 0 ? void 0 : child.uid}` : child === null || child === void 0 ? void 0 : child.uid);
+                    break;
+            }
+        }
+    }
+    async validateGlobalField(tree, field, parent) {
+        await this.lookForReference(tree, field, parent);
+    }
+    async validateModularBlocksField(tree, field, parent) {
+        const { blocks } = field;
+        for (const block of blocks) {
+            const { uid, title } = block;
+            await this.lookForReference([...tree, { uid, name: title }], block, parent + '.' + block.uid);
+        }
+    }
+    async validateGroupField(tree, field, parent) {
+        // NOTE Any Group Field related logic can be added here (Ex data serialization or picking any metadata for report etc.,)
+        await this.lookForReference(tree, field, parent);
+    }
+    async prepareEntryMetaData() {
+        var _a;
+        this.log(messages_1.auditMsg.PREPARING_ENTRY_METADATA, 'info');
+        const localesFolderPath = (0, path_1.resolve)(this.config.basePath, this.config.moduleConfig.locales.dirName);
+        const localesPath = (0, path_1.join)(localesFolderPath, this.config.moduleConfig.locales.fileName);
+        const masterLocalesPath = (0, path_1.join)(localesFolderPath, 'master-locale.json');
+        this.locales = (0, fs_1.existsSync)(masterLocalesPath) ? (0, lodash_1.values)(JSON.parse((0, fs_1.readFileSync)(masterLocalesPath, 'utf8'))) : [];
+        if ((0, fs_1.existsSync)(localesPath)) {
+            this.locales.push(...(0, lodash_1.values)(JSON.parse((0, fs_1.readFileSync)(localesPath, 'utf8'))));
+        }
+        const entriesFolderPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(this.config.basePath), 'entries');
+        for (const { code } of this.locales) {
+            for (const { uid } of (_a = this.ctSchema) !== null && _a !== void 0 ? _a : []) {
+                let basePath = (0, path_1.join)(entriesFolderPath, uid, code);
+                let fsUtility = new cli_utilities_1.FsUtility({ basePath, indexFileName: 'index.json' });
+                let indexer = fsUtility.indexFileContent;
+                for (const _ in indexer) {
+                    const entries = (await fsUtility.readChunkFiles.next());
+                    for (const entryUid in entries) {
+                        let { title } = entries[entryUid];
+                        this.entryMetaData.push({ uid: entryUid, title, ctUid: uid });
+                    }
+                }
+            }
+        }
+    }
+}
+exports.default = FieldRule;

package/lib/modules/global-fields.d.ts

@@ -6,7 +6,7 @@ export default class GlobalField extends ContentType {
      * references.
      * @returns the value of the variable `missingRefs`.
      */
-    run(returnFixSchema?: boolean): Promise<Record<string, any>>;
+    run(returnFixSchema?: boolean): Promise<Record<string, any> | import("../types").ContentTypeStruct[]>;
     /**
      * The function validates a field containing modular blocks by traversing each block and checking for
      * references in a given tree.

package/lib/modules/index.d.ts

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

package/lib/modules/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CustomRoles = exports.Assets = exports.Extensions = exports.Workflows = exports.ContentType = exports.GlobalField = exports.Entries = void 0;
+exports.ModuleDataReader = exports.FieldRule = exports.CustomRoles = exports.Assets = exports.Extensions = exports.Workflows = exports.ContentType = exports.GlobalField = exports.Entries = void 0;
 const tslib_1 = require("tslib");
 const entries_1 = tslib_1.__importDefault(require("./entries"));
 exports.Entries = entries_1.default;
@@ -16,3 +16,7 @@ const custom_roles_1 = tslib_1.__importDefault(require("./custom-roles"));
 exports.CustomRoles = custom_roles_1.default;
 const assets_1 = tslib_1.__importDefault(require("./assets"));
 exports.Assets = assets_1.default;
+const field_rules_1 = tslib_1.__importDefault(require("./field_rules"));
+exports.FieldRule = field_rules_1.default;
+const modulesData_1 = tslib_1.__importDefault(require("./modulesData"));
+exports.ModuleDataReader = modulesData_1.default;

package/lib/modules/modulesData.d.ts

@@ -0,0 +1,18 @@
+import { LogFn, ConfigType, ContentTypeStruct, CtConstructorParam, ModuleConstructorParam } from '../types';
+export default class ModuleDataReader {
+    log: LogFn;
+    config: ConfigType;
+    folderPath: string;
+    assets: Record<string, any>;
+    locales: any[];
+    gfSchema: ContentTypeStruct[];
+    ctSchema: ContentTypeStruct[];
+    environments: string[];
+    auditData: Record<string, unknown>;
+    protected schema: ContentTypeStruct[];
+    constructor({ log, config, ctSchema, gfSchema }: ModuleConstructorParam & CtConstructorParam);
+    getModuleItemCount(moduleName: string): Promise<number>;
+    readUsingFsModule(path: string): Promise<Record<string, any>>;
+    readEntryAssetsModule(basePath: string, module: string): Promise<number>;
+    run(): Promise<Object>;
+}

package/lib/modules/modulesData.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const fs_1 = require("fs");
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+const lodash_1 = require("lodash");
+class ModuleDataReader {
+    constructor({ log, config, ctSchema, gfSchema }) {
+        this.locales = [];
+        this.environments = [];
+        this.auditData = {};
+        this.schema = [];
+        this.log = log;
+        this.config = config;
+        this.ctSchema = ctSchema;
+        this.gfSchema = gfSchema;
+        this.folderPath = (0, path_1.resolve)((0, cli_utilities_1.sanitizePath)(config.basePath));
+    }
+    async getModuleItemCount(moduleName) {
+        let count = 0;
+        switch (moduleName) {
+            case "content-types":
+                count = this.ctSchema.length;
+                break;
+            case 'global-fields':
+                count = this.gfSchema.length;
+                break;
+            case 'assets':
+                count = await this.readEntryAssetsModule((0, path_1.join)(this.folderPath, 'assets'), 'assets') || 0;
+                break;
+            case 'entries':
+                {
+                    const localesFolderPath = (0, path_1.resolve)(this.config.basePath, this.config.moduleConfig.locales.dirName);
+                    const localesPath = (0, path_1.join)(localesFolderPath, this.config.moduleConfig.locales.fileName);
+                    const masterLocalesPath = (0, path_1.join)(localesFolderPath, 'master-locale.json');
+                    this.locales = (0, lodash_1.values)(await this.readUsingFsModule(masterLocalesPath));
+                    if ((0, fs_1.existsSync)(localesPath)) {
+                        this.locales.push(...(0, lodash_1.values)(JSON.parse((0, fs_1.readFileSync)(localesPath, 'utf8'))));
+                    }
+                    for (const { code } of this.locales) {
+                        for (const ctSchema of this.ctSchema) {
+                            const basePath = (0, path_1.join)(this.folderPath, 'entries', ctSchema.uid, code);
+                            count = count + await this.readEntryAssetsModule(basePath, 'index') || 0;
+                        }
+                    }
+                }
+                break;
+            case 'custom-roles':
+            case 'extensions':
+            case 'workflows':
+                count = (0, lodash_1.keys)(await (this.readUsingFsModule((0, path_1.resolve)(this.folderPath, (0, cli_utilities_1.sanitizePath)(this.config.moduleConfig[moduleName].dirName), (0, cli_utilities_1.sanitizePath)(this.config.moduleConfig[moduleName].fileName))))).length;
+                break;
+        }
+        return count;
+    }
+    async readUsingFsModule(path) {
+        const data = (0, fs_1.existsSync)(path) ? (JSON.parse((0, fs_1.readFileSync)(path, 'utf-8'))) : [];
+        return data;
+    }
+    async readEntryAssetsModule(basePath, module) {
+        let fsUtility = new cli_utilities_1.FsUtility({ basePath, indexFileName: `${module}.json` });
+        let indexer = fsUtility.indexFileContent;
+        let count = 0;
+        for (const _ in indexer) {
+            const entries = (await fsUtility.readChunkFiles.next());
+            count = count + Object.keys(entries).length;
+        }
+        return count;
+    }
+    async run() {
+        await Promise.allSettled(Object.keys(this.config.moduleConfig).map(async (module) => {
+            this.auditData[module] = { Total: await this.getModuleItemCount(module) };
+        }));
+        return this.auditData;
+    }
+}
+exports.default = ModuleDataReader;

package/lib/modules/workflows.js

@@ -106,7 +106,7 @@ class Workflows {
                     const { name, uid } = workflow;
                     const warningMessage = (0, messages_1.$t)(messages_1.commonMsg.WORKFLOW_FIX_WARN, { name, uid });
                     this.log(warningMessage, { color: 'yellow' });
-                    if (this.config.flags.yes || (await cli_utilities_1.ux.confirm(messages_1.commonMsg.WORKFLOW_FIX_CONFIRMATION))) {
+                    if (this.config.flags.yes || (await cli_utilities_1.cliux.confirm(messages_1.commonMsg.WORKFLOW_FIX_CONFIRMATION))) {
                         delete newWorkflowSchema[workflow.uid];
                     }
                 }
@@ -120,7 +120,7 @@ class Workflows {
             (this.config.flags['copy-dir'] ||
                 ((_a = this.config.flags['external-config']) === null || _a === void 0 ? void 0 : _a.skipConfirm) ||
                 this.config.flags.yes ||
-                (await cli_utilities_1.ux.confirm(messages_1.commonMsg.FIX_CONFIRMATION)))) {
+                (await cli_utilities_1.cliux.confirm(messages_1.commonMsg.FIX_CONFIRMATION)))) {
             (0, fs_1.writeFileSync)((0, path_1.join)(this.folderPath, this.config.moduleConfig[this.moduleName].fileName), JSON.stringify(newWorkflowSchema));
         }
     }

package/lib/types/common.d.ts

@@ -1,8 +1,6 @@
-import { ux } from "@contentstack/cli-utilities";
-type IFlags = typeof ux.table.Flags;
 type IncludeFlags<T, K extends keyof T> = Pick<T, K>;
 type CommandNames = 'cm:stacks:audit' | 'cm:stacks:audit:fix';
 interface AnyProperty {
     [propName: string]: any;
 }
-export { IFlags, IncludeFlags, CommandNames, AnyProperty };
+export { IncludeFlags, CommandNames, AnyProperty };

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

@@ -1,8 +1,9 @@
 import config from '../config';
 import { AnyProperty } from './common';
 import { ConfigType, LogFn } from './utils';
-type ContentTypeSchemaType = ReferenceFieldDataType | GlobalFieldDataType | ExtensionOrAppFieldDataType | JsonRTEFieldDataType | GroupFieldDataType | ModularBlocksDataType | SelectFeildStruct;
+type ContentTypeSchemaType = ReferenceFieldDataType | GlobalFieldDataType | ExtensionOrAppFieldDataType | JsonRTEFieldDataType | GroupFieldDataType | ModularBlocksDataType | SelectFeildStruct | any;
 type ContentTypeStruct = {
+    field_rules: any;
     uid: string;
     title: string;
     description: string;
@@ -117,7 +118,28 @@ declare enum OutputColumn {
     'asset_uid' = "asset_uid",
     'selectedValue' = "selectedValue",
     'fixStatus' = "fixStatus",
+    'Content_type_uid' = "ct_uid",
+    'action' = "action",
     'field_uid' = "field_uid",
-    'multiple' = "multiple"
+    'multiple' = "multiple",
+    Module = "Module",
+    "Total" = "Total",
+    "Passed" = "Passed",
+    "Fixable" = "Fixable",
+    "Non-Fixable" = "Non-Fixable",
+    "Fixed" = "Fixed",
+    "Not-Fixed" = "Not-Fixed"
 }
-export { CtConstructorParam, ContentTypeStruct, ModuleConstructorParam, ReferenceFieldDataType, GlobalFieldDataType, ExtensionOrAppFieldDataType, JsonRTEFieldDataType, GroupFieldDataType, ModularBlocksDataType, RefErrorReturnType, ModularBlocksSchemaTypes, ModularBlockType, OutputColumn, ContentTypeSchemaType, GlobalFieldSchemaTypes, WorkflowExtensionsRefErrorReturnType, SelectFeildStruct, };
+export { CtConstructorParam, ContentTypeStruct, ModuleConstructorParam, ReferenceFieldDataType, GlobalFieldDataType, ExtensionOrAppFieldDataType, JsonRTEFieldDataType, GroupFieldDataType, ModularBlocksDataType, RefErrorReturnType, ModularBlocksSchemaTypes, ModularBlockType, OutputColumn, ContentTypeSchemaType, GlobalFieldSchemaTypes, WorkflowExtensionsRefErrorReturnType, SelectFeildStruct, FieldRuleStruct, };
+type FieldRuleStruct = {
+    match_type: string;
+    actions: Array<{
+        action: string;
+        target_field: string;
+    }> | undefined;
+    conditions: Array<{
+        value: string;
+        operand_field: string;
+        operator: string;
+    }> | undefined;
+};

package/lib/types/content-types.js

@@ -31,7 +31,15 @@ var OutputColumn;
     OutputColumn["asset_uid"] = "asset_uid";
     OutputColumn["selectedValue"] = "selectedValue";
     OutputColumn["fixStatus"] = "fixStatus";
+    OutputColumn["Content_type_uid"] = "ct_uid";
+    OutputColumn["action"] = "action";
     OutputColumn["field_uid"] = "field_uid";
     OutputColumn["multiple"] = "multiple";
-})(OutputColumn || (OutputColumn = {}));
-exports.OutputColumn = OutputColumn;
+    OutputColumn["Module"] = "Module";
+    OutputColumn["Total"] = "Total";
+    OutputColumn["Passed"] = "Passed";
+    OutputColumn["Fixable"] = "Fixable";
+    OutputColumn["Non-Fixable"] = "Non-Fixable";
+    OutputColumn["Fixed"] = "Fixed";
+    OutputColumn["Not-Fixed"] = "Not-Fixed";
+})(OutputColumn || (exports.OutputColumn = OutputColumn = {}));

package/lib/util/flags.d.ts

@@ -1,13 +1,5 @@
 import { FlagDefinition } from '@contentstack/cli-utilities';
-import { IFlags, IncludeFlags, JSONFlagOptions } from '../types';
-/**
- * The function `getTableFlags` returns a set of table flags based on the specified columns, with
- * updated descriptions and help groups.
- * @param {(keyof IFlags)[]} columns - An optional array of column keys from the IFlags interface. The
- * default value is ['columns', 'sort', 'filter', 'csv', 'no-truncate'].
- * @returns an object of type `IncludeFlags<IFlags, keyof IFlags>`.
- */
-declare function getTableFlags(columns?: (keyof IFlags)[]): IncludeFlags<IFlags, keyof IFlags>;
+import { JSONFlagOptions } from '../types';
 /**
  * The function `getJsonInputFlags` returns a flag definition for parsing JSON input.
  * @param {JSONFlagOptions} options - The `options` parameter is an object that contains the following
@@ -15,4 +7,5 @@ declare function getTableFlags(columns?: (keyof IFlags)[]): IncludeFlags<IFlags,
  * @returns a `FlagDefinition` object.
  */
 declare function getJsonInputFlags(options?: JSONFlagOptions): FlagDefinition<Record<string, unknown>, Record<string, unknown>>;
-export { getTableFlags, getJsonInputFlags };
+declare const tableFlags: import("@contentstack/cli-utilities").FlagInput<import("@contentstack/cli-utilities").TableFlags>;
+export { getJsonInputFlags, tableFlags };