@contentstack/cli-audit 1.3.4 → 1.4.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.3.4 linux-x64 node-v18.19.0
+@contentstack/cli-audit/1.4.0 linux-x64 node-v18.19.1
 $ csdx --help [COMMAND]
 USAGE
   $ csdx COMMAND
@@ -99,14 +99,14 @@ Perform audits and fix possible errors in the exported Contentstack data.
 USAGE
   $ csdx audit:fix [-c <value>] [-d <value>] [--report-path <value>] [--modules
     content-types|global-fields|entries] [--copy-path <value> --copy-dir] [--fix-only
-    reference|global_field|json:rte|json:custom-field|blocks|group] [--columns <value> | ] [--sort <value>] [--filter
+    reference|global_field|json:rte|json:extension|blocks|group] [--columns <value> | ] [--sort <value>] [--filter
     <value>] [--csv | --no-truncate]
 
 FLAGS
   --copy-dir              Create backup from the original data.
   --copy-path=<value>     Provide the path to backup the copied data
   --fix-only=<option>...  Provide the list of fix options
-                          <options: reference|global_field|json:rte|json:custom-field|blocks|group>
+                          <options: reference|global_field|json:rte|json:extension|blocks|group>
   --modules=<option>...   Provide the list of modules to be audited
                           <options: content-types|global-fields|entries>
   --report-path=<value>   Path to store the audit reports
@@ -198,14 +198,14 @@ Perform audits and fix possible errors in the exported Contentstack data.
 USAGE
   $ csdx cm:stacks:audit:fix [-c <value>] [-d <value>] [--report-path <value>] [--modules
     content-types|global-fields|entries] [--copy-path <value> --copy-dir] [--fix-only
-    reference|global_field|json:rte|json:custom-field|blocks|group] [--columns <value> | ] [--sort <value>] [--filter
+    reference|global_field|json:rte|json:extension|blocks|group] [--columns <value> | ] [--sort <value>] [--filter
     <value>] [--csv | --no-truncate]
 
 FLAGS
   --copy-dir              Create backup from the original data.
   --copy-path=<value>     Provide the path to backup the copied data
   --fix-only=<option>...  Provide the list of fix options
-                          <options: reference|global_field|json:rte|json:custom-field|blocks|group>
+                          <options: reference|global_field|json:rte|json:extension|blocks|group>
   --modules=<option>...   Provide the list of modules to be audited
                           <options: content-types|global-fields|entries>
   --report-path=<value>   Path to store the audit reports

package/lib/audit-base-command.js

@@ -143,19 +143,8 @@ class AuditBaseCommand extends base_command_1.BaseCommand {
      * `gfSchema`. The values of these properties are the parsed JSON data from two different files.
      */
     getCtAndGfSchema() {
-        const modules = this.sharedConfig.flags.modules || this.sharedConfig.modules;
         const ctPath = (0, path_1.join)(this.sharedConfig.basePath, this.sharedConfig.moduleConfig['content-types'].dirName, this.sharedConfig.moduleConfig['content-types'].fileName);
         const gfPath = (0, path_1.join)(this.sharedConfig.basePath, this.sharedConfig.moduleConfig['global-fields'].dirName, this.sharedConfig.moduleConfig['global-fields'].fileName);
-        if (modules.includes('content-types')) {
-            if (!(0, fs_1.existsSync)(ctPath)) {
-                this.log(this.$t(messages_1.auditMsg.NOT_VALID_PATH, { path: ctPath }), 'error');
-            }
-        }
-        if (modules.includes('global-fields')) {
-            if (!(0, fs_1.existsSync)(gfPath)) {
-                this.log(this.$t(messages_1.auditMsg.NOT_VALID_PATH, { path: ctPath }), 'error');
-            }
-        }
         const gfSchema = (0, fs_1.existsSync)(gfPath) ? JSON.parse((0, fs_1.readFileSync)(gfPath, 'utf8')) : [];
         const ctSchema = (0, fs_1.existsSync)(ctPath) ? JSON.parse((0, fs_1.readFileSync)(ctPath, 'utf8')) : [];
         return { ctSchema, gfSchema };

package/lib/config/index.d.ts

@@ -26,5 +26,8 @@ declare const config: {
             fileName: string;
         };
     };
+    entries: {
+        systemKeys: string[];
+    };
 };
 export default config;

package/lib/config/index.js

@@ -5,7 +5,7 @@ const config = {
     skipRefs: ['sys_assets'],
     skipFieldTypes: ['taxonomy'],
     modules: ['content-types', 'global-fields', 'entries'],
-    'fix-fields': ['reference', 'global_field', 'json:rte', 'json:custom-field', 'blocks', 'group'],
+    'fix-fields': ['reference', 'global_field', 'json:rte', 'json:extension', 'blocks', 'group'],
     moduleConfig: {
         'content-types': {
             name: 'content type',
@@ -28,5 +28,23 @@ const config = {
             fileName: 'locales.json',
         },
     },
+    entries: {
+        systemKeys: [
+            'uid',
+            'ACL',
+            'tags',
+            'locale',
+            '_version',
+            '_metadata',
+            'published',
+            'created_at',
+            'updated_at',
+            'created_by',
+            'updated_by',
+            '_in_progress',
+            '_restore_status',
+            'publish_details',
+        ],
+    },
 };
 exports.default = config;

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

@@ -1,4 +1,4 @@
-import { LogFn, ConfigType, ModularBlockType, ContentTypeStruct, GroupFieldDataType, RefErrorReturnType, CtConstructorParam, GlobalFieldDataType, JsonRTEFieldDataType, ModularBlocksDataType, ModuleConstructorParam, ReferenceFieldDataType, ContentTypeSchemaType } from '../types';
+import { LogFn, ConfigType, ModularBlockType, ContentTypeStruct, GroupFieldDataType, RefErrorReturnType, CtConstructorParam, GlobalFieldDataType, JsonRTEFieldDataType, ModularBlocksDataType, ModuleConstructorParam, ReferenceFieldDataType, ContentTypeSchemaType, ExtensionOrAppFieldDataType } from '../types';
 import auditConfig from '../config';
 export default class ContentType {
     log: LogFn;
@@ -8,6 +8,7 @@ export default class ContentType {
     folderPath: string;
     currentUid: string;
     currentTitle: string;
+    extensions: string[];
     inMemoryFix: boolean;
     gfSchema: ContentTypeStruct[];
     ctSchema: ContentTypeStruct[];
@@ -21,6 +22,12 @@ export default class ContentType {
      * @returns the `missingRefs` object.
      */
     run(returnFixSchema?: boolean): Promise<Record<string, any>>;
+    /**
+     * @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.
@@ -47,6 +54,15 @@ export default class ContentType {
      * @returns an array of RefErrorReturnType.
      */
     validateReferenceField(tree: Record<string, unknown>[], field: ReferenceFieldDataType): RefErrorReturnType[];
+    /**
+     * The function `validateExtensionAndAppsField` checks if a given field has a valid extension or app
+     * reference and returns any missing references.
+     * @param {Record<string, unknown>[]} tree - An array of objects representing a tree structure.
+     * @param {ExtensionOrAppFieldDataType} field - The `field` parameter is of type `ExtensionOrAppFieldDataType`.
+     * @returns The function `validateExtensionAndAppsField` returns an array of `RefErrorReturnType`
+     * objects.
+     */
+    validateExtensionAndAppField(tree: Record<string, unknown>[], field: ExtensionOrAppFieldDataType): RefErrorReturnType[];
     /**
      * The function "validateGlobalField" asynchronously validates a global field by looking for a
      * reference in a tree data structure.
@@ -130,6 +146,16 @@ export default class ContentType {
      * @returns an array of `ModularBlockType` objects.
      */
     fixModularBlocksReferences(tree: Record<string, unknown>[], blocks: ModularBlockType[]): ModularBlockType[];
+    /**
+     * The function checks for missing extension or app references in a given tree and fixes them if the
+     * fix flag is enabled.
+     * @param {Record<string, unknown>[]} tree - An array of objects representing a tree structure.
+     * @param {ExtensionOrAppFieldDataType} field - The `field` parameter is of type
+     * `ExtensionOrAppFieldDataType`.
+     * @returns If the `fix` flag is true and there are missing references (`missingRefs` is not empty),
+     * then `null` is returned. Otherwise, the `field` parameter is returned.
+     */
+    fixMissingExtensionOrApp(tree: Record<string, unknown>[], field: ExtensionOrAppFieldDataType): ExtensionOrAppFieldDataType | null;
     /**
      * The function `fixMissingReferences` checks for missing references in a given tree and field, and
      * attempts to fix them by removing the missing references from the field's `reference_to` array.

package/lib/modules/content-types.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
+const map_1 = tslib_1.__importDefault(require("lodash/map"));
 const find_1 = tslib_1.__importDefault(require("lodash/find"));
 const isEmpty_1 = tslib_1.__importDefault(require("lodash/isEmpty"));
 const path_1 = require("path");
@@ -11,6 +12,7 @@ const messages_1 = require("../messages");
 generating a report in JSON and CSV formats. */
 class ContentType {
     constructor({ log, fix, config, moduleName, ctSchema, gfSchema }) {
+        this.extensions = [];
         this.inMemoryFix = false;
         this.schema = [];
         this.missingRefs = {};
@@ -32,9 +34,12 @@ class ContentType {
         var _a;
         this.inMemoryFix = returnFixSchema;
         if (!(0, fs_1.existsSync)(this.folderPath)) {
-            throw new Error((0, messages_1.$t)(messages_1.auditMsg.NOT_VALID_PATH, { path: 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 returnFixSchema ? [] : {};
         }
         this.schema = this.moduleName === 'content-types' ? this.ctSchema : this.gfSchema;
+        await this.prerequisiteData();
         for (const schema of (_a = this.schema) !== null && _a !== void 0 ? _a : []) {
             this.currentUid = schema.uid;
             this.currentTitle = schema.title;
@@ -56,6 +61,32 @@ class ContentType {
         }
         return this.missingRefs;
     }
+    /**
+     * @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.
@@ -100,12 +131,13 @@ class ContentType {
                     await this.validateGlobalField([...tree, { uid: child.uid, name: child.display_name }], child);
                     break;
                 case 'json':
-                    if (child.field_metadata.extension) {
-                        if (!fixTypes.includes('json:custom-field'))
+                    if ('extension' in child.field_metadata && child.field_metadata.extension) {
+                        if (!fixTypes.includes('json:extension'))
                             continue;
                         // NOTE Custom field type
+                        this.missingRefs[this.currentUid].push(...this.validateExtensionAndAppField([...tree, { uid: child.uid, name: child.display_name }], child));
                     }
-                    else if (child.field_metadata.allow_json_rte) {
+                    else if ('allow_json_rte' in child.field_metadata && child.field_metadata.allow_json_rte) {
                         if (!fixTypes.includes('json:rte'))
                             continue;
                         // NOTE JSON RTE field type
@@ -132,6 +164,39 @@ class ContentType {
     validateReferenceField(tree, field) {
         return this.validateReferenceToValues(tree, field);
     }
+    /**
+     * The function `validateExtensionAndAppsField` checks if a given field has a valid extension or app
+     * reference and returns any missing references.
+     * @param {Record<string, unknown>[]} tree - An array of objects representing a tree structure.
+     * @param {ExtensionOrAppFieldDataType} field - The `field` parameter is of type `ExtensionOrAppFieldDataType`.
+     * @returns The function `validateExtensionAndAppsField` returns an array of `RefErrorReturnType`
+     * objects.
+     */
+    validateExtensionAndAppField(tree, field) {
+        if (this.fix)
+            return [];
+        const missingRefs = [];
+        let { uid, extension_uid, display_name, data_type } = field;
+        if (!this.extensions.includes(extension_uid)) {
+            missingRefs.push({ uid, extension_uid, type: 'Extension or Apps' });
+        }
+        return missingRefs.length
+            ? [
+                {
+                    tree,
+                    data_type,
+                    missingRefs,
+                    display_name,
+                    ct_uid: this.currentUid,
+                    name: this.currentTitle,
+                    treeStr: tree
+                        .map(({ name }) => name)
+                        .filter((val) => val)
+                        .join(' ➜ '),
+                },
+            ]
+            : [];
+    }
     /**
      * The function "validateGlobalField" asynchronously validates a global field by looking for a
      * reference in a tree data structure.
@@ -219,8 +284,9 @@ class ContentType {
         let { reference_to, display_name, data_type } = field;
         for (const reference of reference_to !== null && reference_to !== void 0 ? reference_to : []) {
             // NOTE Can skip specific references keys (Ex, system defined keys can be skipped)
-            if (this.config.skipRefs.includes(reference))
+            if (this.config.skipRefs.includes(reference)) {
                 continue;
+            }
             const refExist = (0, find_1.default)(this.ctSchema, { uid: reference });
             if (!refExist) {
                 missingRefs.push(reference);
@@ -268,14 +334,14 @@ class ContentType {
                 case 'json':
                 case 'reference':
                     if (data_type === 'json') {
-                        if (field.field_metadata.extension) {
+                        if ('extension' in field.field_metadata && field.field_metadata.extension) {
                             // NOTE Custom field type
-                            if (!fixTypes.includes('json:custom-field'))
+                            if (!fixTypes.includes('json:extension'))
                                 return field;
                             // NOTE Fix logic
-                            return field;
+                            return this.fixMissingExtensionOrApp(tree, field);
                         }
-                        else if (field.field_metadata.allow_json_rte) {
+                        else if ('allow_json_rte' in field.field_metadata && field.field_metadata.allow_json_rte) {
                             if (!fixTypes.includes('json:rte'))
                                 return field;
                             return this.fixMissingReferences(tree, field);
@@ -367,10 +433,10 @@ class ContentType {
             const refErrorObj = {
                 tree,
                 display_name,
-                fixStatus: 'Fixed',
-                missingRefs: [reference_to],
                 ct_uid: this.currentUid,
                 name: this.currentTitle,
+                missingRefs: [reference_to],
+                fixStatus: this.fix ? 'Fixed' : undefined,
                 treeStr: tree.map(({ name }) => name).join(' ➜ '),
             };
             if (!schema) {
@@ -395,6 +461,36 @@ class ContentType {
         })
             .filter((val) => val);
     }
+    /**
+     * The function checks for missing extension or app references in a given tree and fixes them if the
+     * fix flag is enabled.
+     * @param {Record<string, unknown>[]} tree - An array of objects representing a tree structure.
+     * @param {ExtensionOrAppFieldDataType} field - The `field` parameter is of type
+     * `ExtensionOrAppFieldDataType`.
+     * @returns If the `fix` flag is true and there are missing references (`missingRefs` is not empty),
+     * then `null` is returned. Otherwise, the `field` parameter is returned.
+     */
+    fixMissingExtensionOrApp(tree, field) {
+        const missingRefs = [];
+        const { uid, extension_uid, data_type, display_name } = field;
+        if (!this.extensions.includes(extension_uid)) {
+            missingRefs.push({ uid, extension_uid, type: 'Extension or Apps' });
+        }
+        if (this.fix && !(0, isEmpty_1.default)(missingRefs)) {
+            this.missingRefs[this.currentUid].push({
+                tree,
+                data_type,
+                missingRefs,
+                display_name,
+                fixStatus: 'Fixed',
+                ct_uid: this.currentUid,
+                name: this.currentTitle,
+                treeStr: tree.map(({ name }) => name).join(' ➜ '),
+            });
+            return null;
+        }
+        return field;
+    }
     /**
      * The function `fixMissingReferences` checks for missing references in a given tree and field, and
      * attempts to fix them by removing the missing references from the field's `reference_to` array.
@@ -410,8 +506,9 @@ class ContentType {
         const { reference_to, data_type, display_name } = field;
         for (const reference of reference_to !== null && reference_to !== void 0 ? reference_to : []) {
             // NOTE Can skip specific references keys (Ex, system defined keys can be skipped)
-            if (this.config.skipRefs.includes(reference))
+            if (this.config.skipRefs.includes(reference)) {
                 continue;
+            }
             const refExist = (0, find_1.default)(this.ctSchema, { uid: reference });
             if (!refExist) {
                 missingRefs.push(reference);

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 } 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 } from '../types';
 export default class Entries {
     log: LogFn;
     protected fix: boolean;
@@ -9,6 +9,7 @@ export default class Entries {
     folderPath: string;
     currentUid: string;
     currentTitle: string;
+    extensions: string[];
     gfSchema: ContentTypeStruct[];
     ctSchema: ContentTypeStruct[];
     protected entries: Record<string, EntryStruct>;
@@ -63,6 +64,28 @@ export default class Entries {
      * `tree`, `fieldStructure`, and `field`.
      */
     validateReferenceField(tree: Record<string, unknown>[], fieldStructure: ReferenceFieldDataType, field: EntryReferenceFieldDataType[]): EntryRefErrorReturnType[];
+    /**
+     * The function `validateExtensionAndAppField` checks if a given field has a valid extension
+     * reference and returns any missing references.
+     * @param {Record<string, unknown>[]} tree - An array of objects representing a tree structure.
+     * @param {ExtensionOrAppFieldDataType} fieldStructure - The `fieldStructure` parameter is of type
+     * `ExtensionOrAppFieldDataType` and represents the structure of a field in an extension or app. It
+     * contains properties such as `uid`, `display_name`, and `data_type`.
+     * @param {EntryExtensionOrAppFieldDataType} field - The `field` parameter is of type
+     * `EntryExtensionOrAppFieldDataType`, which is an object containing information about a specific
+     * field in an entry. It has the following properties:
+     * @returns an array containing an object if there are missing references. If there are no missing
+     * references, an empty array is returned.
+     */
+    validateExtensionAndAppField(tree: Record<string, unknown>[], fieldStructure: ExtensionOrAppFieldDataType, field: EntryExtensionOrAppFieldDataType): {
+        tree: Record<string, unknown>[];
+        data_type: string;
+        missingRefs: any[];
+        display_name: string;
+        ct_uid: string;
+        name: string;
+        treeStr: string;
+    }[];
     /**
      * The function "validateGlobalField" is an asynchronous function that takes in a tree,
      * fieldStructure, and field as parameters and looks for references in the tree.
@@ -129,6 +152,7 @@ export default class Entries {
      * objects.
      */
     validateReferenceValues(tree: Record<string, unknown>[], fieldStructure: ReferenceFieldDataType, field: EntryReferenceFieldDataType[]): EntryRefErrorReturnType[];
+    removeMissingKeysOnEntry(schema: ContentTypeSchemaType[], entry: EntryFieldType): void;
     /**
      * The function `runFixOnSchema` takes in a tree, schema, and entry, and applies fixes to the entry
      * based on the schema.
@@ -169,6 +193,20 @@ export default class Entries {
      * @returns the updated `entry` array after performing some modifications.
      */
     fixModularBlocksReferences(tree: Record<string, unknown>[], blocks: ModularBlockType[], entry: EntryModularBlocksDataType[]): EntryModularBlocksDataType[];
+    /**
+     * The function `fixMissingExtensionOrApp` checks if a field in an entry has a valid extension or app
+     * reference, and fixes it if necessary.
+     * @param {Record<string, unknown>[]} tree - An array of objects representing a tree structure.
+     * @param {ExtensionOrAppFieldDataType} field - The `field` parameter is of type
+     * `ExtensionOrAppFieldDataType`, which is an object with properties `uid`, `display_name`, and
+     * `data_type`.
+     * @param {EntryExtensionOrAppFieldDataType} entry - The `entry` parameter is of type
+     * `EntryExtensionOrAppFieldDataType`, which is an object containing the data for a specific entry.
+     * It may have a property with the key specified by the `uid` variable, which represents the field
+     * that contains the extension or app data.
+     * @returns the `field` parameter.
+     */
+    fixMissingExtensionOrApp(tree: Record<string, unknown>[], field: ExtensionOrAppFieldDataType, entry: EntryExtensionOrAppFieldDataType): ExtensionOrAppFieldDataType;
     /**
      * The function `fixGroupField` takes in a tree, a field, and an entry, and if the field has a
      * schema, it runs a fix on the schema and returns the updated entry, otherwise it returns the

package/lib/modules/entries.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
+const map_1 = tslib_1.__importDefault(require("lodash/map"));
 const find_1 = tslib_1.__importDefault(require("lodash/find"));
 const values_1 = tslib_1.__importDefault(require("lodash/values"));
 const isEmpty_1 = tslib_1.__importDefault(require("lodash/isEmpty"));
@@ -12,6 +13,7 @@ const messages_1 = require("../messages");
 const global_fields_1 = tslib_1.__importDefault(require("./global-fields"));
 class Entries {
     constructor({ log, fix, config, moduleName, ctSchema, gfSchema }) {
+        this.extensions = [];
         this.missingRefs = {};
         this.entryMetaData = [];
         this.moduleName = 'entries';
@@ -31,7 +33,9 @@ class Entries {
      */
     async run() {
         if (!(0, fs_1.existsSync)(this.folderPath)) {
-            throw new Error((0, messages_1.$t)(messages_1.auditMsg.NOT_VALID_PATH, { path: 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 {};
         }
         await this.prepareEntryMetaData();
         await this.fixPrerequisiteData();
@@ -51,6 +55,9 @@ class Entries {
                         if (!this.missingRefs[this.currentUid]) {
                             this.missingRefs[this.currentUid] = [];
                         }
+                        if (this.fix) {
+                            this.removeMissingKeysOnEntry(ctSchema.schema, this.entries[entryUid]);
+                        }
                         this.lookForReference([{ locale: code, uid, name: title }], ctSchema, this.entries[entryUid]);
                         this.log((0, messages_1.$t)(messages_1.auditMsg.SCAN_ENTRY_SUCCESS_MSG, {
                             title,
@@ -83,6 +90,7 @@ class Entries {
      * `gfSchema` properties using the `ContentType` class.
      */
     async fixPrerequisiteData() {
+        var _a;
         this.ctSchema = (await new content_types_1.default({
             fix: true,
             log: () => { },
@@ -99,6 +107,24 @@ class Entries {
             ctSchema: this.ctSchema,
             gfSchema: this.gfSchema,
         }).run(true));
+        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
@@ -145,10 +171,11 @@ class Entries {
                     this.validateGlobalField([...tree, { uid: child.uid, name: child.display_name, field: uid }], child, entry[uid]);
                     break;
                 case 'json':
-                    if (child.field_metadata.extension) {
+                    if ('extension' in child.field_metadata && child.field_metadata.extension) {
+                        this.missingRefs[this.currentUid].push(...this.validateExtensionAndAppField([...tree, { uid: child.uid, name: child.display_name, field: uid }], child, entry));
                         // NOTE Custom field type
                     }
-                    else if (child.field_metadata.allow_json_rte) {
+                    else if ('allow_json_rte' in child.field_metadata && child.field_metadata.allow_json_rte) {
                         // NOTE JSON RTE field type
                         this.validateJsonRTEFields([...tree, { uid: child.uid, name: child.display_name, field: uid }], child, entry[uid]);
                     }
@@ -178,6 +205,47 @@ class Entries {
     validateReferenceField(tree, fieldStructure, field) {
         return this.validateReferenceValues(tree, fieldStructure, field);
     }
+    /**
+     * The function `validateExtensionAndAppField` checks if a given field has a valid extension
+     * reference and returns any missing references.
+     * @param {Record<string, unknown>[]} tree - An array of objects representing a tree structure.
+     * @param {ExtensionOrAppFieldDataType} fieldStructure - The `fieldStructure` parameter is of type
+     * `ExtensionOrAppFieldDataType` and represents the structure of a field in an extension or app. It
+     * contains properties such as `uid`, `display_name`, and `data_type`.
+     * @param {EntryExtensionOrAppFieldDataType} field - The `field` parameter is of type
+     * `EntryExtensionOrAppFieldDataType`, which is an object containing information about a specific
+     * field in an entry. It has the following properties:
+     * @returns an array containing an object if there are missing references. If there are no missing
+     * references, an empty array is returned.
+     */
+    validateExtensionAndAppField(tree, fieldStructure, field) {
+        if (this.fix)
+            return [];
+        const missingRefs = [];
+        let { uid, display_name, data_type } = fieldStructure || {};
+        if (field[uid]) {
+            let { metadata: { extension_uid } = { extension_uid: '' } } = field[uid] || {};
+            if (extension_uid && !this.extensions.includes(extension_uid)) {
+                missingRefs.push({ uid, extension_uid, type: 'Extension or Apps' });
+            }
+        }
+        return missingRefs.length
+            ? [
+                {
+                    tree,
+                    data_type,
+                    missingRefs,
+                    display_name,
+                    ct_uid: this.currentUid,
+                    name: this.currentTitle,
+                    treeStr: tree
+                        .map(({ name }) => name)
+                        .filter((val) => val)
+                        .join(' ➜ '),
+                },
+            ]
+            : [];
+    }
     /**
      * The function "validateGlobalField" is an asynchronous function that takes in a tree,
      * fieldStructure, and field as parameters and looks for references in the tree.
@@ -315,6 +383,17 @@ class Entries {
             ]
             : [];
     }
+    removeMissingKeysOnEntry(schema, entry) {
+        // NOTE remove invalid entry keys
+        const ctFields = (0, map_1.default)(schema, 'uid');
+        const entryFields = Object.keys(entry !== null && entry !== void 0 ? entry : {});
+        entryFields.forEach((eKey) => {
+            // NOTE Key should not be system key and not exist in schema means it's invalid entry key
+            if (!this.config.entries.systemKeys.includes(eKey) && !ctFields.includes(eKey)) {
+                delete entry[eKey];
+            }
+        });
+    }
     /**
      * The function `runFixOnSchema` takes in a tree, schema, and entry, and applies fixes to the entry
      * based on the schema.
@@ -343,11 +422,12 @@ class Entries {
                 case 'json':
                 case 'reference':
                     if (data_type === 'json') {
-                        if (field.field_metadata.extension) {
+                        if ('extension' in field.field_metadata && field.field_metadata.extension) {
                             // NOTE Custom field type
+                            this.fixMissingExtensionOrApp([...tree, { uid: field.uid, name: field.display_name, data_type: field.data_type }], field, entry);
                             break;
                         }
-                        else if (field.field_metadata.allow_json_rte) {
+                        else if ('allow_json_rte' in field.field_metadata && field.field_metadata.allow_json_rte) {
                             this.fixJsonRteMissingReferences([...tree, { uid: field.uid, name: field.display_name, data_type: field.data_type }], field, entry[uid]);
                             break;
                         }
@@ -408,6 +488,43 @@ class Entries {
         });
         return entry;
     }
+    /**
+     * The function `fixMissingExtensionOrApp` checks if a field in an entry has a valid extension or app
+     * reference, and fixes it if necessary.
+     * @param {Record<string, unknown>[]} tree - An array of objects representing a tree structure.
+     * @param {ExtensionOrAppFieldDataType} field - The `field` parameter is of type
+     * `ExtensionOrAppFieldDataType`, which is an object with properties `uid`, `display_name`, and
+     * `data_type`.
+     * @param {EntryExtensionOrAppFieldDataType} entry - The `entry` parameter is of type
+     * `EntryExtensionOrAppFieldDataType`, which is an object containing the data for a specific entry.
+     * It may have a property with the key specified by the `uid` variable, which represents the field
+     * that contains the extension or app data.
+     * @returns the `field` parameter.
+     */
+    fixMissingExtensionOrApp(tree, field, entry) {
+        const missingRefs = [];
+        let { uid, display_name, data_type } = field || {};
+        if (entry[uid]) {
+            let { metadata: { extension_uid } = { extension_uid: '' } } = entry[uid] || {};
+            if (extension_uid && !this.extensions.includes(extension_uid)) {
+                missingRefs.push({ uid, extension_uid, type: 'Extension or Apps' });
+            }
+        }
+        if (this.fix && !(0, isEmpty_1.default)(missingRefs)) {
+            this.missingRefs[this.currentUid].push({
+                tree,
+                data_type,
+                missingRefs,
+                display_name,
+                fixStatus: 'Fixed',
+                ct_uid: this.currentUid,
+                name: this.currentTitle,
+                treeStr: tree.map(({ name }) => name).join(' ➜ '),
+            });
+            delete entry[uid];
+        }
+        return field;
+    }
     /**
      * The function `fixGroupField` takes in a tree, a field, and an entry, and if the field has a
      * schema, it runs a fix on the schema and returns the updated entry, otherwise it returns the
@@ -589,8 +706,10 @@ class 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, values_1.default)(JSON.parse((0, fs_1.readFileSync)(masterLocalesPath, 'utf8')));
-        this.locales.push(...(0, values_1.default)(JSON.parse((0, fs_1.readFileSync)(localesPath, 'utf8'))));
+        this.locales = (0, fs_1.existsSync)(masterLocalesPath) ? (0, values_1.default)(JSON.parse((0, fs_1.readFileSync)(masterLocalesPath, 'utf8'))) : [];
+        if ((0, fs_1.existsSync)(localesPath)) {
+            this.locales.push(...(0, values_1.default)(JSON.parse((0, fs_1.readFileSync)(localesPath, 'utf8'))));
+        }
         for (const { code } of this.locales) {
             for (const { uid } of this.ctSchema) {
                 let basePath = (0, path_1.join)(this.folderPath, uid, code);

package/lib/types/common.d.ts

@@ -2,4 +2,7 @@ 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';
-export { IFlags, IncludeFlags, CommandNames };
+interface AnyProperty {
+    [propName: string]: any;
+}
+export { IFlags, IncludeFlags, CommandNames, AnyProperty };

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

@@ -1,6 +1,7 @@
 import config from '../config';
+import { AnyProperty } from './common';
 import { ConfigType, LogFn } from './utils';
-type ContentTypeSchemaType = ReferenceFieldDataType | GlobalFieldDataType | CustomFieldDataType | JsonRTEFieldDataType | GroupFieldDataType | ModularBlocksDataType;
+type ContentTypeSchemaType = ReferenceFieldDataType | GlobalFieldDataType | ExtensionOrAppFieldDataType | JsonRTEFieldDataType | GroupFieldDataType | ModularBlocksDataType;
 type ContentTypeStruct = {
     uid: string;
     title: string;
@@ -22,10 +23,9 @@ type CommonDataTypeStruct = {
     data_type: string;
     display_name: string;
     field_metadata: {
-        extension: boolean;
         ref_multiple: boolean;
         allow_json_rte: boolean;
-    } & Record<string, unknown>;
+    } & AnyProperty;
 };
 type RefErrorReturnType = {
     name: string;
@@ -44,9 +44,11 @@ type GlobalFieldDataType = CommonDataTypeStruct & {
     reference_to?: string;
     schema: GlobalFieldSchemaTypes[];
 };
-type CustomFieldDataType = CommonDataTypeStruct & {
-    reference_to: string[];
+type ExtensionOrAppFieldDataType = Omit<CommonDataTypeStruct, 'field_metadata'> & {
     extension_uid: string;
+    field_metadata: {
+        extension: boolean;
+    };
 };
 type JsonRTEFieldDataType = CommonDataTypeStruct & {
     reference_to: string[];
@@ -58,13 +60,13 @@ type ModularBlockType = {
     uid: string;
     title: string;
     reference_to?: string;
-    schema: (JsonRTEFieldDataType | ModularBlocksDataType | ReferenceFieldDataType | CustomFieldDataType | GroupFieldDataType)[];
+    schema: (JsonRTEFieldDataType | ModularBlocksDataType | ReferenceFieldDataType | ExtensionOrAppFieldDataType | GroupFieldDataType)[];
 };
 type ModularBlocksDataType = CommonDataTypeStruct & {
     blocks: ModularBlockType[];
 };
-type GroupFieldSchemaTypes = GroupFieldDataType | CommonDataTypeStruct | GlobalFieldDataType | ReferenceFieldDataType;
-type GlobalFieldSchemaTypes = ReferenceFieldDataType | GroupFieldDataType | CustomFieldDataType;
+type GroupFieldSchemaTypes = GroupFieldDataType | CommonDataTypeStruct | GlobalFieldDataType | ReferenceFieldDataType | ExtensionOrAppFieldDataType;
+type GlobalFieldSchemaTypes = ReferenceFieldDataType | GroupFieldDataType | ExtensionOrAppFieldDataType;
 type ModularBlocksSchemaTypes = ReferenceFieldDataType | JsonRTEFieldDataType;
 declare enum OutputColumn {
     Title = "name",
@@ -73,4 +75,4 @@ declare enum OutputColumn {
     'Missing references' = "missingRefs",
     Path = "treeStr"
 }
-export { CtConstructorParam, ContentTypeStruct, ModuleConstructorParam, ReferenceFieldDataType, GlobalFieldDataType, CustomFieldDataType, JsonRTEFieldDataType, GroupFieldDataType, ModularBlocksDataType, RefErrorReturnType, ModularBlocksSchemaTypes, ModularBlockType, OutputColumn, ContentTypeSchemaType, GlobalFieldSchemaTypes, };
+export { CtConstructorParam, ContentTypeStruct, ModuleConstructorParam, ReferenceFieldDataType, GlobalFieldDataType, ExtensionOrAppFieldDataType, JsonRTEFieldDataType, GroupFieldDataType, ModularBlocksDataType, RefErrorReturnType, ModularBlocksSchemaTypes, ModularBlockType, OutputColumn, ContentTypeSchemaType, GlobalFieldSchemaTypes, };

package/lib/types/entries.d.ts

@@ -1,3 +1,4 @@
+import { AnyProperty } from './common';
 type Locale = {
     uid: string;
     code: string;
@@ -17,8 +18,13 @@ type EntryReferenceFieldDataType = {
 type EntryGlobalFieldDataType = {
     [key: string]: EntryStruct;
 };
-type EntryCustomFieldDataType = {
-    [key: string]: EntryStruct;
+type EntryExtensionOrAppFieldDataType = {
+    [key: string]: {
+        uid: string;
+        metadata: {
+            extension_uid: string;
+        } & AnyProperty;
+    };
 };
 type EntryJsonRTEFieldDataType = {
     uid: string;
@@ -45,5 +51,5 @@ type EntryRefErrorReturnType = {
     tree: Record<string, unknown>[];
     missingRefs: string[] | Record<string, unknown>[];
 };
-type EntryFieldType = EntryStruct | EntryGlobalFieldDataType | EntryModularBlocksDataType | EntryGroupFieldDataType;
-export { Locale, EntryStruct, EntryFieldType, EntryGlobalFieldDataType, EntryCustomFieldDataType, EntryJsonRTEFieldDataType, EntryGroupFieldDataType, EntryModularBlocksDataType, EntryReferenceFieldDataType, EntryRefErrorReturnType, GroupFieldType, EntryModularBlockType, };
+type EntryFieldType = EntryStruct | EntryGlobalFieldDataType | EntryModularBlocksDataType | EntryGroupFieldDataType | EntryExtensionOrAppFieldDataType;
+export { Locale, EntryStruct, EntryFieldType, EntryGlobalFieldDataType, EntryExtensionOrAppFieldDataType, EntryJsonRTEFieldDataType, EntryGroupFieldDataType, EntryModularBlocksDataType, EntryReferenceFieldDataType, EntryRefErrorReturnType, GroupFieldType, EntryModularBlockType, };

package/lib/types/extension.d.ts

@@ -0,0 +1,38 @@
+type AppLocation = 'cs.cm.stack.config' | 'cs.cm.stack.dashboard' | 'cs.cm.stack.sidebar' | 'cs.cm.stack.custom_field' | 'cs.cm.stack.rte' | 'cs.cm.stack.asset_sidebar' | 'cs.org.config';
+interface ExtensionMeta {
+    uid?: string;
+    name?: string;
+    description?: string;
+    path?: string;
+    signed: boolean;
+    extension_uid?: string;
+    data_type?: string;
+    enabled?: boolean;
+    width?: number;
+    blur?: boolean;
+    default_width?: 'full' | 'half';
+}
+interface Extension {
+    type: AppLocation;
+    meta: ExtensionMeta[];
+}
+interface LocationConfiguration {
+    signed: boolean;
+    base_url: string;
+    locations: Extension[];
+}
+type MarketplaceAppsInstallationData = {
+    uid: string;
+    status: string;
+    configuration: any;
+    server_configuration: any;
+    target: {
+        type: string;
+        uid: string;
+    };
+    ui_location: LocationConfiguration;
+} & AnyProperty;
+interface AnyProperty {
+    [propName: string]: any;
+}
+export { MarketplaceAppsInstallationData };

package/lib/types/extension.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.3.4",
+  "version": "1.4.0",
   "commands": {
     "cm:stacks:audit:fix": {
       "id": "cm:stacks:audit:fix",
@@ -85,7 +85,7 @@
             "reference",
             "global_field",
             "json:rte",
-            "json:custom-field",
+            "json:extension",
             "blocks",
             "group"
           ]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentstack/cli-audit",
-  "version": "1.3.4",
+  "version": "1.4.0",
   "description": "Contentstack audit plugin",
   "author": "Contentstack CLI",
   "homepage": "https://github.com/contentstack/cli",
@@ -19,7 +19,7 @@
   ],
   "dependencies": {
     "@contentstack/cli-command": "~1.2.16",
-    "@contentstack/cli-utilities": "~1.5.11",
+    "@contentstack/cli-utilities": "~1.5.12",
     "@oclif/plugin-help": "^5",
     "@oclif/plugin-plugins": "^4.1.9",
     "chalk": "^4.1.2",
@@ -31,7 +31,7 @@
   },
   "devDependencies": {
     "@contentstack/cli-dev-dependencies": "^1.2.4",
-    "@oclif/test": "^2.0.3",
+    "@oclif/test": "^2.5.6",
     "@types/chai": "^4.3.5",
     "@types/fs-extra": "^11.0.2",
     "@types/mocha": "^10.0.6",