@contentstack/cli-audit 1.9.0 → 1.11.0

package/lib/config/index.js

@@ -4,7 +4,16 @@ const config = {
     showTerminalOutput: true,
     skipRefs: ['sys_assets'],
     skipFieldTypes: ['taxonomy', 'group'],
-    modules: ['content-types', 'global-fields', 'entries', 'extensions', 'workflows', 'custom-roles', 'assets'],
+    modules: [
+        'content-types',
+        'global-fields',
+        'entries',
+        'extensions',
+        'workflows',
+        'custom-roles',
+        'assets',
+        'field-rules',
+    ],
     'fix-fields': ['reference', 'global_field', 'json:rte', 'json:extension', 'blocks', 'group', 'content_types'],
     moduleConfig: {
         'content-types': {
@@ -42,16 +51,16 @@ const config = {
             dirName: 'custom-roles',
             fileName: 'custom-roles.json',
         },
-        'assets': {
+        assets: {
             name: 'assets',
             dirName: 'assets',
             fileName: 'assets.json',
         },
-        'environments': {
+        environments: {
             name: 'environments',
             dirName: 'environments',
             fileName: 'environments.json',
-        }
+        },
     },
     entries: {
         systemKeys: [
@@ -96,16 +105,26 @@ const config = {
         'publish_locale',
         'publish_environment',
         'asset_uid',
-        'selectedValue'
+        'selectedValue',
+        'ct_uid',
+        'action',
     ],
     ReportTitleForEntries: {
         Entries_Select_feild: 'Entries_Select_feild',
         Entries_Mandatory_feild: 'Entries_Mandatory_feild',
         Entries_Title_feild: 'Entries_Title_feild',
         Entry_Missing_Locale_and_Env: 'Entry_Missing_Locale_and_Env',
-        Entry_Missing_Locale_and_Env_in_Publish_Details: 'Entry_Missing_Locale_and_Env_in_Publish_Details'
+        Entry_Missing_Locale_and_Env_in_Publish_Details: 'Entry_Missing_Locale_and_Env_in_Publish_Details',
+        Entry_Multiple_Fields: "Entry_Multiple_Fields"
     },
-    feild_level_modules: ['Entries_Title_feild', 'Entries_Mandatory_feild', 'Entries_Select_feild', 'Entry_Missing_Locale_and_Env_in_Publish_Details'],
-    fixSelectField: false
+    feild_level_modules: [
+        'Entries_Title_feild',
+        'Entries_Mandatory_feild',
+        'Entries_Select_feild',
+        'Entry_Missing_Locale_and_Env_in_Publish_Details',
+        'field-rules',
+        'Entry_Multiple_Fields'
+    ],
+    fixSelectField: false,
 };
 exports.default = config;

package/lib/messages/index.d.ts

@@ -38,6 +38,10 @@ declare const auditMsg: {
     CT_REFERENCE_FIELD: string;
     ASSET_NOT_EXIST: string;
     ENTRY_PUBLISH_DETAILS_NOT_EXIST: string;
+    FIELD_RULE_CONDITION_ABSENT: string;
+    FIELD_RULE_TARGET_ABSENT: string;
+    FIELD_RULE_CONDITION_SCAN_MESSAGE: string;
+    FIELD_RULE_TARGET_SCAN_MESSAGE: string;
 };
 declare const auditFixMsg: {
     COPY_DATA: string;
@@ -50,6 +54,7 @@ declare const auditFixMsg: {
     ENTRY_MANDATORY_FIELD_FIX: string;
     ENTRY_SELECT_FIELD_FIX: string;
     ASSET_FIX: string;
+    FIELD_RULE_FIX_MESSAGE: string;
 };
 declare const messages: typeof errors & typeof commonMsg & typeof auditMsg & typeof auditFixMsg & typeof tableColumnDescriptions;
 /**

package/lib/messages/index.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tableColumnDescriptions = exports.auditFixMsg = exports.auditMsg = exports.commonMsg = exports.errors = exports.$t = void 0;
+exports.tableColumnDescriptions = exports.auditFixMsg = exports.auditMsg = exports.commonMsg = exports.errors = void 0;
+exports.$t = $t;
 const tslib_1 = require("tslib");
 const memoize_1 = tslib_1.__importDefault(require("lodash/memoize"));
 const errors = {};
@@ -46,6 +47,10 @@ const auditMsg = {
     CT_REFERENCE_FIELD: `The mentioned Reference field is not Array field reference is '{reference_to}' having display name '{display_name}''`,
     ASSET_NOT_EXIST: `The publish_details either does not exist or is not an array for asset uid '{uid}'`,
     ENTRY_PUBLISH_DETAILS_NOT_EXIST: `The publish_details either does not exist or is not an array for entry uid '{uid}'`,
+    FIELD_RULE_CONDITION_ABSENT: `The operand field '{condition_field}' is not present in the schema of the content-type {ctUid}`,
+    FIELD_RULE_TARGET_ABSENT: `The target field '{target_field}' is not present in the schema of the content-type {ctUid}`,
+    FIELD_RULE_CONDITION_SCAN_MESSAGE: `Completed Scanning of Field Rule '{num}' condition of Content-type '{ctUid}'`,
+    FIELD_RULE_TARGET_SCAN_MESSAGE: `Completed Scanning of Field Rule '{num}' target of Content-type '{ctUid}'`
 };
 exports.auditMsg = auditMsg;
 const auditFixMsg = {
@@ -59,6 +64,7 @@ const auditFixMsg = {
     ENTRY_MANDATORY_FIELD_FIX: `Removing the publish details from the entry with UID '{uid}' in Locale '{locale}'...`,
     ENTRY_SELECT_FIELD_FIX: `Adding the value '{value}' in the select field of entry UID '{uid}'...`,
     ASSET_FIX: `Fixed publish detials for Asset with UID '{uid}'`,
+    FIELD_RULE_FIX_MESSAGE: `Fixed Field Rule '{num}' target of Content-type '{ctUid}`,
 };
 exports.auditFixMsg = auditFixMsg;
 const messages = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, errors), commonMsg), auditMsg), auditFixMsg), tableColumnDescriptions);
@@ -84,5 +90,4 @@ function $t(msg, args) {
     });
     return transfer(msg, args);
 }
-exports.$t = $t;
 exports.default = messages;

package/lib/modules/assets.d.ts

@@ -21,7 +21,7 @@ export default class Assets {
      * iterates over the schema and looks for references, and returns a list of missing references.
      * @returns the `missingEnvLocales` object.
      */
-    run(returnFixSchema?: boolean): Promise<Record<string, any>>;
+    run(returnFixSchema?: boolean): Promise<Record<string, any> | ContentTypeStruct[]>;
     /**
      * @method prerequisiteData
      * The `prerequisiteData` function reads and parses JSON files to retrieve extension and marketplace

package/lib/modules/assets.js

@@ -80,7 +80,7 @@ class Assets {
         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));

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

@@ -22,7 +22,7 @@ export default class ContentType {
      * iterates over the schema and looks for references, and returns a list of missing references.
      * @returns the `missingRefs` object.
      */
-    run(returnFixSchema?: boolean): Promise<Record<string, any>>;
+    run(returnFixSchema?: boolean): Promise<Record<string, any> | ContentTypeStruct[]>;
     /**
      * @method prerequisiteData
      * The `prerequisiteData` function reads and parses JSON files to retrieve extension and marketplace

package/lib/modules/content-types.js

@@ -102,7 +102,7 @@ class ContentType {
         let canWrite = true;
         if (!this.inMemoryFix && 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.ux.confirm(messages_1.commonMsg.FIX_CONFIRMATION));
+                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));

package/lib/modules/custom-roles.js

@@ -117,7 +117,7 @@ class CustomRoles {
             (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(newCustomRoleSchema));
         }
     }

package/lib/modules/entries.d.ts

@@ -18,6 +18,7 @@ export default class Entries {
     protected missingMandatoryFields: Record<string, any>;
     protected missingTitleFields: Record<string, any>;
     protected missingEnvLocale: Record<string, any>;
+    protected missingMultipleField: Record<string, any>;
     environments: string[];
     entryMetaData: Record<string, any>[];
     moduleName: keyof typeof auditConfig.moduleConfig;
@@ -34,12 +35,14 @@ export default class Entries {
         missingMandatoryFields?: undefined;
         missingTitleFields?: undefined;
         missingEnvLocale?: undefined;
+        missingMultipleFields?: undefined;
     } | {
         missingEntryRefs: Record<string, any>;
         missingSelectFeild: Record<string, any>;
         missingMandatoryFields: Record<string, any>;
         missingTitleFields: Record<string, any>;
         missingEnvLocale: Record<string, any>;
+        missingMultipleFields: Record<string, any>;
     }>;
     /**
      * The function removes any properties from the `missingRefs` object that have an empty array value.
@@ -195,6 +198,7 @@ export default class Entries {
      * @returns if there is missing field returns field and path
      * Else empty array
      */
+    removeEmojiAndImages(str: string): string;
     validateSelectField(tree: Record<string, unknown>[], fieldStructure: SelectFeildStruct, field: any): {
         uid: string;
         name: string;

package/lib/modules/entries.js

@@ -21,6 +21,7 @@ class Entries {
         this.missingMandatoryFields = {};
         this.missingTitleFields = {};
         this.missingEnvLocale = {};
+        this.missingMultipleField = {};
         this.environments = [];
         this.entryMetaData = [];
         this.moduleName = 'entries';
@@ -66,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] = [];
                         }
@@ -78,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;
@@ -177,6 +179,7 @@ class Entries {
             missingMandatoryFields: this.missingMandatoryFields,
             missingTitleFields: this.missingTitleFields,
             missingEnvLocale: this.missingEnvLocale,
+            missingMultipleFields: this.missingMultipleField
         };
     }
     /**
@@ -249,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));
@@ -274,7 +277,24 @@ class Entries {
             entry = this.runFixOnSchema(tree, field.schema, entry);
         }
         for (const child of (_a = field === null || field === void 0 ? void 0 : field.schema) !== null && _a !== void 0 ? _a : []) {
-            const { uid } = child;
+            const { uid, multiple, data_type } = child;
+            if (multiple && entry[uid] && !Array.isArray(entry[uid])) {
+                if (!this.missingMultipleField[this.currentUid]) {
+                    this.missingMultipleField[this.currentUid] = [];
+                }
+                this.missingMultipleField[this.currentUid].push({
+                    uid: this.currentUid,
+                    name: this.currentTitle,
+                    field_uid: uid,
+                    data_type,
+                    multiple,
+                    tree,
+                    treeStr: tree
+                        .map(({ name }) => name)
+                        .filter((val) => val)
+                        .join(' ➜ '),
+                });
+            }
             this.missingMandatoryFields[this.currentUid].push(...this.validateMandatoryFields([...tree, { uid: field.uid, name: child.display_name, field: uid }], child, entry));
             if (!(entry === null || entry === void 0 ? void 0 : entry[uid]) && !child.hasOwnProperty('display_type')) {
                 continue;
@@ -551,10 +571,29 @@ class Entries {
     runFixOnSchema(tree, schema, entry) {
         // NOTE Global field Fix
         schema.forEach((field) => {
-            const { uid, data_type } = field;
+            var _a;
+            var _b, _c;
+            const { uid, data_type, multiple } = field;
             if (!Object(entry).hasOwnProperty(uid)) {
                 return;
             }
+            if (multiple && entry[uid] && !Array.isArray(entry[uid])) {
+                (_a = (_b = this.missingMultipleField)[_c = this.currentUid]) !== null && _a !== void 0 ? _a : (_b[_c] = []);
+                this.missingMultipleField[this.currentUid].push({
+                    uid: this.currentUid,
+                    name: this.currentTitle,
+                    field_uid: uid,
+                    data_type,
+                    multiple,
+                    tree,
+                    treeStr: tree
+                        .map(({ name }) => name)
+                        .filter(Boolean)
+                        .join(' ➜ '),
+                    'fixStatus': 'Fixed',
+                });
+                entry[uid] = [entry[uid]];
+            }
             switch (data_type) {
                 case 'global_field':
                     entry[uid] = this.fixGlobalFieldReferences([...tree, { uid: field.uid, name: field.display_name, data_type: field.data_type }], field, entry[uid]);
@@ -603,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({ action: actions, ctUid: this.currentUid });
+        }
+    }
+    /**
+     * @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.