@contentstack/cli-audit 1.5.4 → 1.6.0

package/README.md

@@ -19,7 +19,7 @@ $ npm install -g @contentstack/cli-audit
 $ csdx COMMAND
 running command...
 $ csdx (--version|-v)
-@contentstack/cli-audit/1.5.4 linux-x64 node-v18.20.2
+@contentstack/cli-audit/1.6.0 linux-x64 node-v18.20.2
 $ csdx --help [COMMAND]
 USAGE
   $ csdx COMMAND
@@ -285,7 +285,7 @@ EXAMPLES
   $ csdx plugins
 ```
 
-_See code: [@oclif/plugin-plugins](https://github.com/oclif/plugin-plugins/blob/v5.0.11/src/commands/plugins/index.ts)_
+_See code: [@oclif/plugin-plugins](https://github.com/oclif/plugin-plugins/blob/v5.0.19/src/commands/plugins/index.ts)_
 
 ## `csdx plugins:add PLUGIN`
 
@@ -359,7 +359,7 @@ EXAMPLES
   $ csdx plugins:inspect myplugin
 ```
 
-_See code: [@oclif/plugin-plugins](https://github.com/oclif/plugin-plugins/blob/v5.0.11/src/commands/plugins/inspect.ts)_
+_See code: [@oclif/plugin-plugins](https://github.com/oclif/plugin-plugins/blob/v5.0.19/src/commands/plugins/inspect.ts)_
 
 ## `csdx plugins:install PLUGIN`
 
@@ -408,7 +408,7 @@ EXAMPLES
     $ csdx plugins:install someuser/someplugin
 ```
 
-_See code: [@oclif/plugin-plugins](https://github.com/oclif/plugin-plugins/blob/v5.0.11/src/commands/plugins/install.ts)_
+_See code: [@oclif/plugin-plugins](https://github.com/oclif/plugin-plugins/blob/v5.0.19/src/commands/plugins/install.ts)_
 
 ## `csdx plugins:link PATH`
 
@@ -438,7 +438,7 @@ EXAMPLES
   $ csdx plugins:link myplugin
 ```
 
-_See code: [@oclif/plugin-plugins](https://github.com/oclif/plugin-plugins/blob/v5.0.11/src/commands/plugins/link.ts)_
+_See code: [@oclif/plugin-plugins](https://github.com/oclif/plugin-plugins/blob/v5.0.19/src/commands/plugins/link.ts)_
 
 ## `csdx plugins:remove [PLUGIN]`
 
@@ -479,7 +479,7 @@ FLAGS
   --reinstall  Reinstall all plugins after uninstalling.
 ```
 
-_See code: [@oclif/plugin-plugins](https://github.com/oclif/plugin-plugins/blob/v5.0.11/src/commands/plugins/reset.ts)_
+_See code: [@oclif/plugin-plugins](https://github.com/oclif/plugin-plugins/blob/v5.0.19/src/commands/plugins/reset.ts)_
 
 ## `csdx plugins:uninstall [PLUGIN]`
 
@@ -507,7 +507,7 @@ EXAMPLES
   $ csdx plugins:uninstall myplugin
 ```
 
-_See code: [@oclif/plugin-plugins](https://github.com/oclif/plugin-plugins/blob/v5.0.11/src/commands/plugins/uninstall.ts)_
+_See code: [@oclif/plugin-plugins](https://github.com/oclif/plugin-plugins/blob/v5.0.19/src/commands/plugins/uninstall.ts)_
 
 ## `csdx plugins:unlink [PLUGIN]`
 
@@ -551,5 +551,5 @@ DESCRIPTION
   Update installed plugins.
 ```
 
-_See code: [@oclif/plugin-plugins](https://github.com/oclif/plugin-plugins/blob/v5.0.11/src/commands/plugins/update.ts)_
+_See code: [@oclif/plugin-plugins](https://github.com/oclif/plugin-plugins/blob/v5.0.19/src/commands/plugins/update.ts)_
 <!-- commandsstop -->

package/lib/audit-base-command.d.ts

@@ -29,6 +29,8 @@ export declare abstract class AuditBaseCommand extends BaseCommand<typeof AuditB
         missingEntryRefs: Record<string, any> | undefined;
         missingCtRefsInExtensions: {} | undefined;
         missingCtRefsInWorkflow: {} | undefined;
+        missingSelectFeild: Record<string, any> | undefined;
+        missingMandatoryFields: Record<string, any> | undefined;
     }>;
     /**
      * The `promptQueue` function prompts the user to enter a data directory path if the `data-dir` flag
@@ -74,7 +76,7 @@ export declare abstract class AuditBaseCommand extends BaseCommand<typeof AuditB
      * 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>;
+    prepareReport(moduleName: keyof typeof config.moduleConfig | keyof typeof config.ReportTitleForEntries, 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.
@@ -85,5 +87,5 @@ export declare abstract class AuditBaseCommand extends BaseCommand<typeof AuditB
      * 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>;
+    prepareCSV(moduleName: keyof typeof config.moduleConfig | keyof typeof config.ReportTitleForEntries, listOfMissingRefs: Record<string, any>): Promise<void>;
 }

package/lib/audit-base-command.js

@@ -11,6 +11,7 @@ const path_1 = require("path");
 const cloneDeep_1 = tslib_1.__importDefault(require("lodash/cloneDeep"));
 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");
@@ -39,7 +40,7 @@ class AuditBaseCommand extends base_command_1.BaseCommand {
         await this.promptQueue();
         await this.createBackUp();
         this.sharedConfig.reportPath = (0, path_1.resolve)(this.flags['report-path'] || process.cwd(), 'audit-report');
-        const { missingCtRefs, missingGfRefs, missingEntryRefs, missingCtRefsInExtensions, missingCtRefsInWorkflow } = await this.scanAndFix();
+        const { missingCtRefs, missingGfRefs, missingEntryRefs, missingCtRefsInExtensions, missingCtRefsInWorkflow, missingSelectFeild, missingMandatoryFields, } = await this.scanAndFix();
         this.showOutputOnScreen([
             { module: 'Content types', missingRefs: missingCtRefs },
             { module: 'Global Fields', missingRefs: missingGfRefs },
@@ -47,11 +48,16 @@ class AuditBaseCommand extends base_command_1.BaseCommand {
         ]);
         this.showOutputOnScreenWorkflowsAndExtension([{ module: 'Extensions', missingRefs: missingCtRefsInExtensions }]);
         this.showOutputOnScreenWorkflowsAndExtension([{ module: 'Workflows', missingRefs: missingCtRefsInWorkflow }]);
+        this.showOutputOnScreenWorkflowsAndExtension([{ module: 'Entries Select Field', missingRefs: missingSelectFeild }]);
+        this.showOutputOnScreenWorkflowsAndExtension([
+            { module: 'Entries Mandatory Field', missingRefs: missingMandatoryFields },
+        ]);
         if (!(0, isEmpty_1.default)(missingCtRefs) ||
             !(0, isEmpty_1.default)(missingGfRefs) ||
             !(0, isEmpty_1.default)(missingEntryRefs) ||
             !(0, isEmpty_1.default)(missingCtRefsInWorkflow) ||
-            !(0, isEmpty_1.default)(missingCtRefsInExtensions)) {
+            !(0, isEmpty_1.default)(missingCtRefsInExtensions) ||
+            !(0, isEmpty_1.default)(missingSelectFeild)) {
             if (this.currentCommand === 'cm:stacks:audit') {
                 this.log(this.$t(messages_1.auditMsg.FINAL_REPORT_PATH, { path: this.sharedConfig.reportPath }), 'warn');
             }
@@ -73,7 +79,8 @@ class AuditBaseCommand extends base_command_1.BaseCommand {
             !(0, isEmpty_1.default)(missingGfRefs) ||
             !(0, isEmpty_1.default)(missingEntryRefs) ||
             !(0, isEmpty_1.default)(missingCtRefsInWorkflow) ||
-            !(0, isEmpty_1.default)(missingCtRefsInExtensions));
+            !(0, isEmpty_1.default)(missingCtRefsInExtensions) ||
+            !(0, isEmpty_1.default)(missingSelectFeild));
     }
     /**
      * The `scan` function performs an audit on different modules (content-types, global-fields, and
@@ -82,8 +89,9 @@ class AuditBaseCommand extends base_command_1.BaseCommand {
      * and `missingEntryRefs`.
      */
     async scanAndFix() {
+        var _a, _b, _c;
         let { ctSchema, gfSchema } = this.getCtAndGfSchema();
-        let missingCtRefs, missingGfRefs, missingEntryRefs, missingCtRefsInExtensions, missingCtRefsInWorkflow;
+        let missingCtRefs, missingGfRefs, missingEntryRefs, missingCtRefsInExtensions, missingCtRefsInWorkflow, missingSelectFeild, missingEntry, missingMandatoryFields;
         for (const module of this.sharedConfig.flags.modules || this.sharedConfig.modules) {
             (0, log_1.print)([
                 {
@@ -110,8 +118,13 @@ class AuditBaseCommand extends base_command_1.BaseCommand {
                     await this.prepareReport(module, missingGfRefs);
                     break;
                 case 'entries':
-                    missingEntryRefs = await new modules_1.Entries((0, cloneDeep_1.default)(constructorParam)).run();
+                    missingEntry = await new modules_1.Entries((0, cloneDeep_1.default)(constructorParam)).run();
+                    missingEntryRefs = (_a = missingEntry.missingEntryRefs) !== null && _a !== void 0 ? _a : {};
+                    missingSelectFeild = (_b = missingEntry.missingSelectFeild) !== null && _b !== void 0 ? _b : {};
+                    missingMandatoryFields = (_c = missingEntry.missingMandatoryFields) !== null && _c !== void 0 ? _c : {};
                     await this.prepareReport(module, missingEntryRefs);
+                    await this.prepareReport(`Entries_Select_feild`, missingSelectFeild);
+                    await this.prepareReport('Entries_Mandatory_feild', missingMandatoryFields);
                     break;
                 case 'workflows':
                     missingCtRefsInWorkflow = await new modules_1.Workflows({
@@ -141,7 +154,15 @@ class AuditBaseCommand extends base_command_1.BaseCommand {
                 },
             ]);
         }
-        return { missingCtRefs, missingGfRefs, missingEntryRefs, missingCtRefsInExtensions, missingCtRefsInWorkflow };
+        return {
+            missingCtRefs,
+            missingGfRefs,
+            missingEntryRefs,
+            missingCtRefsInExtensions,
+            missingCtRefsInWorkflow,
+            missingSelectFeild,
+            missingMandatoryFields,
+        };
     }
     /**
      * The `promptQueue` function prompts the user to enter a data directory path if the `data-dir` flag
@@ -241,15 +262,16 @@ class AuditBaseCommand extends base_command_1.BaseCommand {
             return;
         }
         this.log(''); // Adding a new line
-        for (const { module, missingRefs } of allMissingRefs) {
+        for (let { module, missingRefs } of allMissingRefs) {
             if ((0, isEmpty_1.default)(missingRefs)) {
                 continue;
             }
             (0, log_1.print)([{ bold: true, color: 'cyan', message: ` ${module}` }]);
             const tableValues = Object.values(missingRefs).flat();
+            missingRefs = Object.values(missingRefs).flat();
             const tableKeys = Object.keys(missingRefs[0]);
             const arrayOfObjects = tableKeys.map((key) => {
-                if (['title', 'name', 'uid', 'content_types', 'branches', 'fixStatus'].includes(key)) {
+                if (config_1.default.OutputTableKeys.includes(key)) {
                     return {
                         [key]: {
                             minWidth: 7,
@@ -258,7 +280,10 @@ class AuditBaseCommand extends base_command_1.BaseCommand {
                                 if (key === 'fixStatus') {
                                     return chalk_1.default.green(typeof row[key] === 'object' ? JSON.stringify(row[key]) : row[key]);
                                 }
-                                else if (key === 'content_types' || key === 'branches') {
+                                else if (key === 'content_types' ||
+                                    key === 'branches' ||
+                                    key === 'missingCTSelectFieldValues' ||
+                                    key === 'missingFieldUid') {
                                     return chalk_1.default.red(typeof row[key] === 'object' ? JSON.stringify(row[key]) : row[key]);
                                 }
                                 else {

package/lib/config/index.d.ts

@@ -39,5 +39,10 @@ declare const config: {
     entries: {
         systemKeys: string[];
     };
+    OutputTableKeys: string[];
+    ReportTitleForEntries: {
+        Entries_Select_feild: string;
+        Entries_Mandatory_feild: string;
+    };
 };
 export default config;

package/lib/config/index.js

@@ -56,5 +56,27 @@ const config = {
             'publish_details',
         ],
     },
+    //These keys will be used output the modules with issues and fixes on console
+    OutputTableKeys: [
+        'title',
+        'name',
+        'uid',
+        'content_types',
+        'branches',
+        'fixStatus',
+        'tree',
+        'display_name',
+        'display_type',
+        'missingRefs',
+        'treeStr',
+        'missingCTSelectFieldValues',
+        'min_instance',
+        'missingFieldUid',
+        'isPublished',
+    ],
+    ReportTitleForEntries: {
+        Entries_Select_feild: 'Entries_Select_feild',
+        Entries_Mandatory_feild: 'Entries_Mandatory_feild',
+    },
 };
 exports.default = config;

package/lib/messages/index.d.ts

@@ -39,6 +39,8 @@ declare const auditFixMsg: {
     EMPTY_FIX_MSG: string;
     AUDIT_FIX_CMD_DESCRIPTION: string;
     WF_FIX_MSG: string;
+    ENTRY_MANDATORY_FIELD_FIX: string;
+    ENTRY_SELECT_FIELD_FIX: string;
 };
 declare const messages: typeof errors & typeof commonMsg & typeof auditMsg & typeof auditFixMsg & typeof tableColumnDescriptions;
 /**

package/lib/messages/index.js

@@ -49,6 +49,8 @@ const auditFixMsg = {
     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.',
     WF_FIX_MSG: 'Successfully removed the workflow {uid} named {name}.',
+    ENTRY_MANDATORY_FIELD_FIX: `Removing the publish details from entry uid '{uid}' from locale '{locale}'`,
+    ENTRY_SELECT_FIELD_FIX: `Adding the value '{value}' in select field of uid '{uid}'`
 };
 exports.auditFixMsg = auditFixMsg;
 const messages = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, errors), commonMsg), auditMsg), auditFixMsg), tableColumnDescriptions);

package/lib/modules/entries.d.ts

@@ -1,5 +1,5 @@
 import auditConfig from '../config';
-import { LogFn, Locale, ConfigType, EntryStruct, EntryFieldType, ModularBlockType, ContentTypeStruct, CtConstructorParam, GroupFieldDataType, GlobalFieldDataType, JsonRTEFieldDataType, ContentTypeSchemaType, ModularBlocksDataType, ModuleConstructorParam, ReferenceFieldDataType, EntryRefErrorReturnType, EntryGroupFieldDataType, EntryGlobalFieldDataType, EntryJsonRTEFieldDataType, EntryModularBlocksDataType, EntryReferenceFieldDataType, ExtensionOrAppFieldDataType, EntryExtensionOrAppFieldDataType } from '../types';
+import { LogFn, Locale, ConfigType, EntryStruct, EntryFieldType, ModularBlockType, ContentTypeStruct, CtConstructorParam, GroupFieldDataType, GlobalFieldDataType, JsonRTEFieldDataType, ContentTypeSchemaType, ModularBlocksDataType, ModuleConstructorParam, ReferenceFieldDataType, EntryRefErrorReturnType, EntryGroupFieldDataType, EntryGlobalFieldDataType, EntryJsonRTEFieldDataType, EntryModularBlocksDataType, EntryReferenceFieldDataType, ExtensionOrAppFieldDataType, EntryExtensionOrAppFieldDataType, SelectFeildStruct } from '../types';
 export default class Entries {
     log: LogFn;
     protected fix: boolean;
@@ -14,6 +14,8 @@ export default class Entries {
     ctSchema: ContentTypeStruct[];
     protected entries: Record<string, EntryStruct>;
     protected missingRefs: Record<string, any>;
+    protected missingSelectFeild: Record<string, any>;
+    protected missingMandatoryFields: Record<string, any>;
     entryMetaData: Record<string, any>[];
     moduleName: keyof typeof auditConfig.moduleConfig;
     isEntryWithoutTitleField: boolean;
@@ -23,7 +25,15 @@ export default class Entries {
      * 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(): Promise<{
+        missingEntryRefs?: undefined;
+        missingSelectFeild?: undefined;
+        missingMandatoryFields?: undefined;
+    } | {
+        missingEntryRefs: Record<string, any>;
+        missingSelectFeild: Record<string, any>;
+        missingMandatoryFields: Record<string, any>;
+    }>;
     /**
      * The function removes any properties from the `missingRefs` object that have an empty array value.
      */
@@ -169,6 +179,54 @@ export default class Entries {
      * `schema`.
      */
     runFixOnSchema(tree: Record<string, unknown>[], schema: ContentTypeSchemaType[], entry: EntryFieldType): EntryFieldType;
+    /**
+     * We check for the select field with condition in order of multiple -> Array
+     * We find the missing values i.e. the values present in entry but not in the options of the content-type
+     * @param tree : Contains all the tree where the select field is located used for getting the path to it
+     * @param fieldStructure it contains the Content-type structure of the field
+     * @param field It contains the value that is present in the entry it can be array or value of number | string
+     * @returns if there is missing field returns field and path
+     * Else empty array
+     */
+    validateSelectField(tree: Record<string, unknown>[], fieldStructure: SelectFeildStruct, field: any): {
+        uid: string;
+        name: string;
+        display_name: string;
+        display_type: string;
+        missingCTSelectFieldValues: any;
+        min_instance: string | number;
+        tree: Record<string, unknown>[];
+        treeStr: string;
+    }[];
+    /**
+     * This functions check which of the select values used in entry is/are not present in the Content-type
+     * Then removes those values from entry
+     * If the entry is empty then adds the first value of the options
+     * If the entry has multiple choices and min_instances then adds that number of instances
+     * @param {Record<string, unknown>}tree Contains the path where the select field can be found
+     * @param field : It contains the content-type structure of the select field
+     * @param entry : it contains the value in the entry of select field one of the options of the CT.
+     * @returns
+     */
+    fixSelectField(tree: Record<string, unknown>[], field: SelectFeildStruct, entry: any): any;
+    validateMandatoryFields(tree: Record<string, unknown>[], fieldStructure: any, entry: any): {
+        uid: string;
+        name: string;
+        display_name: any;
+        missingFieldUid: any;
+        tree: Record<string, unknown>[];
+        treeStr: string;
+    }[];
+    /**
+     *
+     * @param field It contains the value to be searched
+     * @param selectOptions It contains the options that were added in CT
+     * @returns An Array of entry containing only the values that were present in CT, An array of not present entries
+     */
+    findNotPresentSelectField(field: any, selectOptions: any): {
+        filteredFeild: any[];
+        notPresent: any[];
+    };
     /**
      * The function `fixGlobalFieldReferences` adds a new entry to a tree data structure and runs a fix
      * on the schema.

package/lib/modules/entries.js

@@ -16,6 +16,8 @@ class Entries {
     constructor({ log, fix, config, moduleName, ctSchema, gfSchema }) {
         this.extensions = [];
         this.missingRefs = {};
+        this.missingSelectFeild = {};
+        this.missingMandatoryFields = {};
         this.entryMetaData = [];
         this.moduleName = 'entries';
         this.isEntryWithoutTitleField = false;
@@ -57,10 +59,34 @@ class Entries {
                         if (!this.missingRefs[this.currentUid]) {
                             this.missingRefs[this.currentUid] = [];
                         }
+                        if (!this.missingSelectFeild[this.currentUid]) {
+                            this.missingSelectFeild[this.currentUid] = [];
+                        }
+                        if (!this.missingMandatoryFields[this.currentUid]) {
+                            this.missingMandatoryFields[this.currentUid] = [];
+                        }
                         if (this.fix) {
                             this.removeMissingKeysOnEntry(ctSchema.schema, this.entries[entryUid]);
                         }
                         this.lookForReference([{ locale: code, uid, name: title }], ctSchema, this.entries[entryUid]);
+                        const fields = this.missingMandatoryFields[uid];
+                        const isPublished = entry.publish_details.length > 0;
+                        if ((this.fix && fields.length && isPublished) || (!this.fix && fields)) {
+                            const fixStatus = this.fix ? 'Fixed' : '';
+                            fields === null || fields === void 0 ? void 0 : fields.forEach((field) => {
+                                field.isPublished = isPublished;
+                                if (this.fix && isPublished) {
+                                    field.fixStatus = fixStatus;
+                                }
+                            });
+                            if (this.fix && isPublished) {
+                                this.log((0, messages_1.$t)(messages_1.auditFixMsg.ENTRY_MANDATORY_FIELD_FIX, { uid, locale: code }), 'error');
+                                entry.publish_details = [];
+                            }
+                        }
+                        else {
+                            delete this.missingMandatoryFields[uid];
+                        }
                         const message = (0, messages_1.$t)(messages_1.auditMsg.SCAN_ENTRY_SUCCESS_MSG, {
                             title,
                             local: code,
@@ -77,7 +103,11 @@ class Entries {
         }
         // this.log('', 'info'); // Adding empty line
         this.removeEmptyVal();
-        return this.missingRefs;
+        return {
+            missingEntryRefs: this.missingRefs,
+            missingSelectFeild: this.missingSelectFeild,
+            missingMandatoryFields: this.missingMandatoryFields,
+        };
     }
     /**
      * The function removes any properties from the `missingRefs` object that have an empty array value.
@@ -88,6 +118,16 @@ class Entries {
                 delete this.missingRefs[propName];
             }
         }
+        for (let propName in this.missingSelectFeild) {
+            if (!this.missingSelectFeild[propName].length) {
+                delete this.missingSelectFeild[propName];
+            }
+        }
+        for (let propName in this.missingMandatoryFields) {
+            if (!this.missingMandatoryFields[propName].length) {
+                delete this.missingMandatoryFields[propName];
+            }
+        }
     }
     /**
      * The function `fixPrerequisiteData` fixes the prerequisite data by updating the `ctSchema` and
@@ -163,10 +203,12 @@ class Entries {
         if (this.fix) {
             entry = this.runFixOnSchema(tree, field.schema, entry);
         }
-        for (const child of (_a = field.schema) !== null && _a !== void 0 ? _a : []) {
+        for (const child of (_a = field === null || field === void 0 ? void 0 : field.schema) !== null && _a !== void 0 ? _a : []) {
             const { uid } = child;
-            if (!(entry === null || entry === void 0 ? void 0 : entry[uid]))
+            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;
+            }
             switch (child.data_type) {
                 case 'reference':
                     this.missingRefs[this.currentUid].push(...this.validateReferenceField([...tree, { uid: child.uid, name: child.display_name, field: uid }], child, entry[uid]));
@@ -190,6 +232,12 @@ class Entries {
                 case 'group':
                     this.validateGroupField([...tree, { uid: field.uid, name: child.display_name, field: uid }], child, entry[uid]);
                     break;
+                case 'text':
+                case 'number':
+                    if (child.hasOwnProperty('display_type')) {
+                        this.missingSelectFeild[this.currentUid].push(...this.validateSelectField([...tree, { uid: field.uid, name: child.display_name, field: uid }], child, entry[uid]));
+                    }
+                    break;
             }
         }
     }
@@ -453,10 +501,205 @@ class Entries {
                 case 'group':
                     entry[uid] = this.fixGroupField([...tree, { uid: field.uid, name: field.display_name, data_type: field.data_type }], field, entry[uid]);
                     break;
+                case 'text':
+                case 'number':
+                    if (field.hasOwnProperty('display_type')) {
+                        entry[uid] = this.fixSelectField([...tree, { uid: field.uid, name: field.display_name, data_type: field.data_type }], field, entry[uid]);
+                    }
+                    break;
             }
         });
         return entry;
     }
+    /**
+     * We check for the select field with condition in order of multiple -> Array
+     * We find the missing values i.e. the values present in entry but not in the options of the content-type
+     * @param tree : Contains all the tree where the select field is located used for getting the path to it
+     * @param fieldStructure it contains the Content-type structure of the field
+     * @param field It contains the value that is present in the entry it can be array or value of number | string
+     * @returns if there is missing field returns field and path
+     * Else empty array
+     */
+    validateSelectField(tree, fieldStructure, field) {
+        const { display_name, enum: selectOptions, multiple, min_instance, display_type } = fieldStructure;
+        if (field === null || field === '' || (field === null || field === void 0 ? void 0 : field.length) === 0 || !field) {
+            let missingCTSelectFieldValues = 'Not Selected';
+            return [
+                {
+                    uid: this.currentUid,
+                    name: this.currentTitle,
+                    display_name,
+                    display_type,
+                    missingCTSelectFieldValues,
+                    min_instance: min_instance !== null && min_instance !== void 0 ? min_instance : 'NA',
+                    tree,
+                    treeStr: tree
+                        .map(({ name }) => name)
+                        .filter((val) => val)
+                        .join(' ➜ '),
+                },
+            ];
+        }
+        let missingCTSelectFieldValues;
+        if (multiple) {
+            if (Array.isArray(field)) {
+                let obj = this.findNotPresentSelectField(field, selectOptions);
+                let { notPresent } = obj;
+                if (notPresent.length) {
+                    missingCTSelectFieldValues = notPresent;
+                }
+            }
+        }
+        else if (!selectOptions.choices.some((choice) => choice.value === field)) {
+            missingCTSelectFieldValues = field;
+        }
+        if (display_type && missingCTSelectFieldValues) {
+            return [
+                {
+                    uid: this.currentUid,
+                    name: this.currentTitle,
+                    display_name,
+                    display_type,
+                    missingCTSelectFieldValues,
+                    min_instance: min_instance !== null && min_instance !== void 0 ? min_instance : 'NA',
+                    tree,
+                    treeStr: tree
+                        .map(({ name }) => name)
+                        .filter((val) => val)
+                        .join(' ➜ '),
+                },
+            ];
+        }
+        else {
+            return [];
+        }
+    }
+    /**
+     * This functions check which of the select values used in entry is/are not present in the Content-type
+     * Then removes those values from entry
+     * If the entry is empty then adds the first value of the options
+     * If the entry has multiple choices and min_instances then adds that number of instances
+     * @param {Record<string, unknown>}tree Contains the path where the select field can be found
+     * @param field : It contains the content-type structure of the select field
+     * @param entry : it contains the value in the entry of select field one of the options of the CT.
+     * @returns
+     */
+    fixSelectField(tree, field, entry) {
+        const { enum: selectOptions, multiple, min_instance, display_type, display_name, uid } = field;
+        let missingCTSelectFieldValues;
+        let isMissingValuePresent = false;
+        if (multiple) {
+            let obj = this.findNotPresentSelectField(entry, selectOptions);
+            let { notPresent, filteredFeild } = obj;
+            entry = filteredFeild;
+            missingCTSelectFieldValues = notPresent;
+            if (missingCTSelectFieldValues.length) {
+                isMissingValuePresent = true;
+            }
+            if (min_instance && Array.isArray(entry)) {
+                const missingInstances = min_instance - entry.length;
+                if (missingInstances > 0) {
+                    isMissingValuePresent = true;
+                    const newValues = selectOptions.choices
+                        .filter((choice) => !entry.includes(choice.value))
+                        .slice(0, missingInstances)
+                        .map((choice) => choice.value);
+                    entry.push(...newValues);
+                    this.log((0, messages_1.$t)(messages_1.auditFixMsg.ENTRY_SELECT_FIELD_FIX, { value: newValues.join(' '), uid }), 'error');
+                }
+            }
+            else {
+                if (entry.length === 0) {
+                    isMissingValuePresent = true;
+                    const defaultValue = selectOptions.choices.length > 0 ? selectOptions.choices[0].value : null;
+                    entry.push(defaultValue);
+                    this.log((0, messages_1.$t)(messages_1.auditFixMsg.ENTRY_SELECT_FIELD_FIX, { value: defaultValue, uid }), 'error');
+                }
+            }
+        }
+        else {
+            const isPresent = selectOptions.choices.some((choice) => choice.value === entry);
+            if (!isPresent) {
+                missingCTSelectFieldValues = entry;
+                isMissingValuePresent = true;
+                let defaultValue = selectOptions.choices.length > 0 ? selectOptions.choices[0].value : null;
+                entry = defaultValue;
+                this.log((0, messages_1.$t)(messages_1.auditFixMsg.ENTRY_SELECT_FIELD_FIX, { value: defaultValue, uid }), 'error');
+            }
+        }
+        if (display_type && isMissingValuePresent) {
+            this.missingSelectFeild[this.currentUid].push({
+                uid: this.currentUid,
+                name: this.currentTitle,
+                display_name,
+                display_type,
+                missingCTSelectFieldValues,
+                min_instance: min_instance !== null && min_instance !== void 0 ? min_instance : 'NA',
+                tree,
+                treeStr: tree
+                    .map(({ name }) => name)
+                    .filter((val) => val)
+                    .join(' ➜ '),
+                fixStatus: 'Fixed',
+            });
+        }
+        return entry;
+    }
+    validateMandatoryFields(tree, fieldStructure, entry) {
+        const { display_name, multiple, data_type, mandatory, field_metadata, uid } = fieldStructure;
+        const isJsonRteEmpty = () => {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+            const jsonNode = multiple
+                ? (_f = (_e = (_d = (_c = (_b = (_a = entry[uid]) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.children) === null || _c === void 0 ? void 0 : _c[0]) === null || _d === void 0 ? void 0 : _d.children) === null || _e === void 0 ? void 0 : _e[0]) === null || _f === void 0 ? void 0 : _f.text
+                : (_l = (_k = (_j = (_h = (_g = entry[uid]) === null || _g === void 0 ? void 0 : _g.children) === null || _h === void 0 ? void 0 : _h[0]) === null || _j === void 0 ? void 0 : _j.children) === null || _k === void 0 ? void 0 : _k[0]) === null || _l === void 0 ? void 0 : _l.text;
+            return jsonNode === '';
+        };
+        const isEntryEmpty = () => {
+            var _a;
+            const fieldValue = multiple ? (_a = entry[uid]) === null || _a === void 0 ? void 0 : _a.length : entry[uid];
+            return fieldValue === '' || !fieldValue;
+        };
+        if (mandatory) {
+            if ((data_type === 'json' && field_metadata.allow_json_rte && isJsonRteEmpty()) ||
+                (!(data_type === 'json') && isEntryEmpty())) {
+                return [
+                    {
+                        uid: this.currentUid,
+                        name: this.currentTitle,
+                        display_name,
+                        missingFieldUid: uid,
+                        tree,
+                        treeStr: tree
+                            .filter(({ name }) => name)
+                            .map(({ name }) => name)
+                            .join(' ➜ '),
+                    },
+                ];
+            }
+        }
+        return [];
+    }
+    /**
+     *
+     * @param field It contains the value to be searched
+     * @param selectOptions It contains the options that were added in CT
+     * @returns An Array of entry containing only the values that were present in CT, An array of not present entries
+     */
+    findNotPresentSelectField(field, selectOptions) {
+        let present = [];
+        let notPresent = [];
+        const choicesMap = new Map(selectOptions.choices.map((choice) => [choice.value, choice]));
+        for (const value of field) {
+            const choice = choicesMap.get(value);
+            if (choice) {
+                present.push(choice.value);
+            }
+            else {
+                notPresent.push(value);
+            }
+        }
+        return { filteredFeild: present, notPresent };
+    }
     /**
      * The function `fixGlobalFieldReferences` adds a new entry to a tree data structure and runs a fix
      * on the schema.
@@ -733,7 +976,11 @@ class Entries {
                     const entries = (await fsUtility.readChunkFiles.next());
                     for (const entryUid in entries) {
                         let { title } = entries[entryUid];
-                        if (!title) {
+                        if (entries[entryUid].hasOwnProperty('title') && !title) {
+                            this.isEntryWithoutTitleField = true;
+                            this.log(`The 'title' field in Entry with UID '${entryUid}' of Content Type '${uid}' in Locale '${code}' is empty.`, `error`);
+                        }
+                        else if (!title) {
                             this.isEntryWithoutTitleField = true;
                             this.log(`Entry with UID '${entryUid}' of Content Type '${uid}' in Locale '${code}' does not have a 'title' field.`, `error`);
                         }
@@ -743,7 +990,7 @@ class Entries {
             }
         }
         if (this.isEntryWithoutTitleField) {
-            throw Error(`Entries found with missing 'title' field! Please make the data corrections and re-run the audit.`);
+            // throw Error(`Entries found with missing 'title' field! Please make the data corrections and re-run the audit.`);
         }
     }
 }

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

@@ -1,12 +1,13 @@
 import config from '../config';
 import { AnyProperty } from './common';
 import { ConfigType, LogFn } from './utils';
-type ContentTypeSchemaType = ReferenceFieldDataType | GlobalFieldDataType | ExtensionOrAppFieldDataType | JsonRTEFieldDataType | GroupFieldDataType | ModularBlocksDataType;
+type ContentTypeSchemaType = ReferenceFieldDataType | GlobalFieldDataType | ExtensionOrAppFieldDataType | JsonRTEFieldDataType | GroupFieldDataType | ModularBlocksDataType | SelectFeildStruct;
 type ContentTypeStruct = {
     uid: string;
     title: string;
     description: string;
     schema?: ContentTypeSchemaType[];
+    mandatory: boolean;
 };
 type ModuleConstructorParam = {
     log: LogFn;
@@ -26,6 +27,7 @@ type CommonDataTypeStruct = {
         ref_multiple: boolean;
         allow_json_rte: boolean;
     } & AnyProperty;
+    mandatory: boolean;
 };
 type RefErrorReturnType = {
     name: string;
@@ -66,23 +68,38 @@ type ModularBlockType = {
     uid: string;
     title: string;
     reference_to?: string;
-    schema: (JsonRTEFieldDataType | ModularBlocksDataType | ReferenceFieldDataType | ExtensionOrAppFieldDataType | GroupFieldDataType)[];
+    schema: (JsonRTEFieldDataType | ModularBlocksDataType | ReferenceFieldDataType | ExtensionOrAppFieldDataType | GroupFieldDataType | SelectFeildStruct)[];
 };
 type ModularBlocksDataType = CommonDataTypeStruct & {
     blocks: ModularBlockType[];
 };
-type GroupFieldSchemaTypes = GroupFieldDataType | CommonDataTypeStruct | GlobalFieldDataType | ReferenceFieldDataType | ExtensionOrAppFieldDataType;
-type GlobalFieldSchemaTypes = ReferenceFieldDataType | GroupFieldDataType | ExtensionOrAppFieldDataType;
-type ModularBlocksSchemaTypes = ReferenceFieldDataType | JsonRTEFieldDataType;
+type GroupFieldSchemaTypes = GroupFieldDataType | CommonDataTypeStruct | GlobalFieldDataType | ReferenceFieldDataType | ExtensionOrAppFieldDataType | SelectFeildStruct;
+type GlobalFieldSchemaTypes = ReferenceFieldDataType | GroupFieldDataType | ExtensionOrAppFieldDataType | SelectFeildStruct;
+type ModularBlocksSchemaTypes = ReferenceFieldDataType | JsonRTEFieldDataType | SelectFeildStruct;
+type SelectFeildStruct = CommonDataTypeStruct & {
+    display_type: string;
+    enum: {
+        advanced: string;
+        choices: Record<string, unknown>[];
+    };
+    min_instance?: number;
+    max_instance?: number;
+    multiple: boolean;
+};
 declare enum OutputColumn {
     Title = "name",
     'Field name' = "display_name",
     'Field type' = "data_type",
+    'Display type' = "display_type",
     'Missing references' = "missingRefs",
     Path = "treeStr",
     title = "title",
     'uid' = "uid",
     'missingCts' = "content_types",
-    'Missing Branches' = "branches"
+    'Missing Branches' = "branches",
+    'MissingValues' = "missingCTSelectFieldValues",
+    'Minimum Required Instaces' = "min_instance",
+    'missingFieldUid' = "missingFieldUid",
+    'isPublished' = "isPublished"
 }
-export { CtConstructorParam, ContentTypeStruct, ModuleConstructorParam, ReferenceFieldDataType, GlobalFieldDataType, ExtensionOrAppFieldDataType, JsonRTEFieldDataType, GroupFieldDataType, ModularBlocksDataType, RefErrorReturnType, ModularBlocksSchemaTypes, ModularBlockType, OutputColumn, ContentTypeSchemaType, GlobalFieldSchemaTypes, WorkflowExtensionsRefErrorReturnType, };
+export { CtConstructorParam, ContentTypeStruct, ModuleConstructorParam, ReferenceFieldDataType, GlobalFieldDataType, ExtensionOrAppFieldDataType, JsonRTEFieldDataType, GroupFieldDataType, ModularBlocksDataType, RefErrorReturnType, ModularBlocksSchemaTypes, ModularBlockType, OutputColumn, ContentTypeSchemaType, GlobalFieldSchemaTypes, WorkflowExtensionsRefErrorReturnType, SelectFeildStruct, };

package/lib/types/content-types.js

@@ -6,11 +6,16 @@ var OutputColumn;
     OutputColumn["Title"] = "name";
     OutputColumn["Field name"] = "display_name";
     OutputColumn["Field type"] = "data_type";
+    OutputColumn["Display type"] = "display_type";
     OutputColumn["Missing references"] = "missingRefs";
     OutputColumn["Path"] = "treeStr";
     OutputColumn["title"] = "title";
     OutputColumn["uid"] = "uid";
     OutputColumn["missingCts"] = "content_types";
     OutputColumn["Missing Branches"] = "branches";
+    OutputColumn["MissingValues"] = "missingCTSelectFieldValues";
+    OutputColumn["Minimum Required Instaces"] = "min_instance";
+    OutputColumn["missingFieldUid"] = "missingFieldUid";
+    OutputColumn["isPublished"] = "isPublished";
 })(OutputColumn || (OutputColumn = {}));
 exports.OutputColumn = OutputColumn;

package/lib/types/entries.d.ts

@@ -8,6 +8,7 @@ type Locale = {
 type EntryStruct = {
     uid: string;
     title: string;
+    publish_details: [];
 } & {
     [key: string]: EntryReferenceFieldDataType[] | EntryGlobalFieldDataType | EntryJsonRTEFieldDataType | EntryGroupFieldDataType | EntryModularBlocksDataType[];
 };
@@ -35,6 +36,10 @@ type GroupFieldType = EntryReferenceFieldDataType[] | EntryGlobalFieldDataType |
 type EntryGroupFieldDataType = {
     [key: string]: GroupFieldType;
 };
+type SelectValue = string | string[] | number | number;
+type EntrySelectFeildDataType = {
+    [key: string]: SelectValue;
+};
 type EntryModularBlockType = {
     [key: string]: EntryJsonRTEFieldDataType | EntryModularBlocksDataType | EntryReferenceFieldDataType[] | EntryGroupFieldDataType;
 };
@@ -51,5 +56,7 @@ type EntryRefErrorReturnType = {
     tree: Record<string, unknown>[];
     missingRefs: string[] | Record<string, unknown>[];
 };
-type EntryFieldType = EntryStruct | EntryGlobalFieldDataType | EntryModularBlocksDataType | EntryGroupFieldDataType | EntryExtensionOrAppFieldDataType;
-export { Locale, EntryStruct, EntryFieldType, EntryGlobalFieldDataType, EntryExtensionOrAppFieldDataType, EntryJsonRTEFieldDataType, EntryGroupFieldDataType, EntryModularBlocksDataType, EntryReferenceFieldDataType, EntryRefErrorReturnType, GroupFieldType, EntryModularBlockType, };
+type EntryFieldType = EntryStruct | EntryGlobalFieldDataType | EntryModularBlocksDataType | EntryGroupFieldDataType | EntryExtensionOrAppFieldDataType | EntrySelectFeildDataType | {
+    [key: string]: any;
+};
+export { Locale, EntryStruct, EntryFieldType, EntryGlobalFieldDataType, EntryExtensionOrAppFieldDataType, EntryJsonRTEFieldDataType, EntryGroupFieldDataType, EntryModularBlocksDataType, EntryReferenceFieldDataType, EntryRefErrorReturnType, GroupFieldType, EntryModularBlockType, EntrySelectFeildDataType, SelectValue };

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.5.4",
+  "version": "1.6.0",
   "commands": {
     "cm:stacks:audit:fix": {
       "id": "cm:stacks:audit:fix",

package/package.json

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