@contentstack/cli-audit 1.0.0 → 1.2.1

package/lib/modules/entries.js

@@ -2,25 +2,27 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 const find_1 = tslib_1.__importDefault(require("lodash/find"));
+const core_1 = require("@oclif/core");
 const values_1 = tslib_1.__importDefault(require("lodash/values"));
 const isEmpty_1 = tslib_1.__importDefault(require("lodash/isEmpty"));
 const path_1 = require("path");
-const fs_1 = require("fs");
 const cli_utilities_1 = require("@contentstack/cli-utilities");
+const fs_1 = require("fs");
+const content_types_1 = tslib_1.__importDefault(require("./content-types"));
 const messages_1 = require("../messages");
 class Entries {
-    constructor({ log, config, moduleName, ctSchema, gfSchema }) {
+    constructor({ log, fix, config, moduleName, ctSchema, gfSchema }) {
         this.missingRefs = {};
         this.entryMetaData = [];
-        this.moduleName = 'content-types';
+        this.moduleName = 'entries';
         this.log = log;
         this.config = config;
+        this.fix = fix !== null && fix !== void 0 ? fix : false;
         this.ctSchema = ctSchema;
         this.gfSchema = gfSchema;
+        this.moduleName = moduleName !== null && moduleName !== void 0 ? moduleName : 'entries';
         this.fileName = config.moduleConfig[this.moduleName].fileName;
         this.folderPath = (0, path_1.resolve)(config.basePath, config.moduleConfig.entries.dirName);
-        if (moduleName)
-            this.moduleName = moduleName;
     }
     /**
      * The `run` function checks if a folder path exists, sets the schema based on the module name,
@@ -32,36 +34,82 @@ class Entries {
             throw new Error((0, messages_1.$t)(messages_1.auditMsg.NOT_VALID_PATH, { path: this.folderPath }));
         }
         await this.prepareEntryMetaData();
+        await this.fixPrerequisiteData();
         for (const { code } of this.locales) {
             for (const ctSchema of this.ctSchema) {
                 const basePath = (0, path_1.join)(this.folderPath, ctSchema.uid, code);
                 const fsUtility = new cli_utilities_1.FsUtility({ basePath, indexFileName: 'index.json' });
                 const indexer = fsUtility.indexFileContent;
-                for (const _ in indexer) {
+                for (const fileIndex in indexer) {
                     const entries = (await fsUtility.readChunkFiles.next());
-                    for (const entryUid in entries) {
-                        let entry = entries[entryUid];
+                    this.entries = entries;
+                    for (const entryUid in this.entries) {
+                        const entry = this.entries[entryUid];
                         const { uid, title } = entry;
                         this.currentUid = uid;
                         this.currentTitle = title;
                         this.missingRefs[this.currentUid] = [];
-                        await this.lookForReference([{ uid, name: title }], ctSchema, entry);
+                        this.lookForReference([{ uid, name: title }], ctSchema, this.entries[entryUid]);
                         this.log((0, messages_1.$t)(messages_1.auditMsg.SCAN_ENTRY_SUCCESS_MSG, {
                             title,
                             local: code,
                             module: this.config.moduleConfig.entries.name,
                         }), 'info');
                     }
+                    if (this.fix) {
+                        await this.writeFixContent(`${basePath}/${indexer[fileIndex]}`, this.entries);
+                    }
                 }
             }
         }
         this.log('', 'info'); // Adding empty line
+        this.removeEmptyVal();
+        return this.missingRefs;
+    }
+    /**
+     * The function removes any properties from the `missingRefs` object that have an empty array value.
+     */
+    removeEmptyVal() {
         for (let propName in this.missingRefs) {
             if (!this.missingRefs[propName].length) {
                 delete this.missingRefs[propName];
             }
         }
-        return this.missingRefs;
+    }
+    /**
+     * The function `fixPrerequisiteData` fixes the prerequisite data by updating the `ctSchema` and
+     * `gfSchema` properties using the `ContentType` class.
+     */
+    async fixPrerequisiteData() {
+        this.ctSchema = (await new content_types_1.default({
+            fix: true,
+            log: () => { },
+            config: this.config,
+            moduleName: 'content-types',
+            ctSchema: this.ctSchema,
+            gfSchema: this.gfSchema,
+        }).run(true));
+        this.gfSchema = (await new content_types_1.default({
+            fix: true,
+            log: () => { },
+            config: this.config,
+            moduleName: 'entries',
+            ctSchema: this.ctSchema,
+            gfSchema: this.gfSchema,
+        }).run(true));
+    }
+    /**
+     * 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(filePath, schema) {
+        let canWrite = true;
+        if (this.fix && !this.config.flags['copy-dir']) {
+            canWrite = this.config.flags.yes || (await core_1.ux.confirm(messages_1.commonMsg.FIX_CONFIRMATION));
+        }
+        if (canWrite) {
+            (0, fs_1.writeFileSync)(filePath, JSON.stringify(schema));
+        }
     }
     /**
      * The function `lookForReference` iterates over a given schema and validates different field types
@@ -75,30 +123,36 @@ class Entries {
      * EntryGroupFieldDataType} entry - The `entry` parameter is an object that represents the data of an
      * entry. It can have different types depending on the `schema` parameter.
      */
-    async lookForReference(tree, { schema }, entry) {
-        for (const field of schema !== null && schema !== void 0 ? schema : []) {
-            const { uid } = field;
-            switch (field.data_type) {
+    lookForReference(tree, field, entry) {
+        var _a;
+        if (this.fix) {
+            entry = this.runFixOnSchema(tree, field.schema, entry);
+        }
+        for (const child of (_a = field.schema) !== null && _a !== void 0 ? _a : []) {
+            const { uid } = child;
+            if (!(entry === null || entry === void 0 ? void 0 : entry[uid]))
+                return;
+            switch (child.data_type) {
                 case 'reference':
-                    this.missingRefs[this.currentUid].push(...this.validateReferenceField([...tree, { uid: field.uid, name: field.display_name, field: uid }], field, entry[uid]));
+                    this.missingRefs[this.currentUid].push(...this.validateReferenceField([...tree, { uid: child.uid, name: child.display_name, field: uid }], child, entry[uid]));
                     break;
                 case 'global_field':
-                    await this.validateGlobalField([...tree, { uid: field.uid, name: field.display_name, field: uid }], field, entry[uid]);
+                    this.validateGlobalField([...tree, { uid: child.uid, name: child.display_name, field: uid }], child, entry[uid]);
                     break;
                 case 'json':
-                    if (field.field_metadata.extension) {
+                    if (child.field_metadata.extension) {
                         // NOTE Custom field type
                     }
-                    else if (field.field_metadata.allow_json_rte) {
+                    else if (child.field_metadata.allow_json_rte) {
                         // NOTE JSON RTE field type
-                        await this.validateJsonRTEFields([...tree, { uid: field.uid, name: field.display_name, field: uid }], field, entry[uid]);
+                        this.validateJsonRTEFields([...tree, { uid: child.uid, name: child.display_name, field: uid }], child, entry[uid]);
                     }
                     break;
                 case 'blocks':
-                    await this.validateModularBlocksField([...tree, { uid: field.uid, name: field.display_name, field: uid }], field, entry[uid]);
+                    this.validateModularBlocksField([...tree, { uid: child.uid, name: child.display_name, field: uid }], child, entry[uid]);
                     break;
                 case 'group':
-                    await this.validateGroupField([...tree, { uid: field.uid, name: field.display_name, field: uid }], field, entry[uid]);
+                    this.validateGroupField([...tree, { uid: field.uid, name: child.display_name, field: uid }], child, entry[uid]);
                     break;
             }
         }
@@ -131,9 +185,9 @@ class Entries {
      * @param {EntryGlobalFieldDataType} field - The `field` parameter is of type
      * `EntryGlobalFieldDataType`. It represents a single global field entry.
      */
-    async validateGlobalField(tree, fieldStructure, field) {
+    validateGlobalField(tree, fieldStructure, field) {
         // NOTE Any GlobalField related logic can be added here
-        await this.lookForReference(tree, fieldStructure, field);
+        this.lookForReference(tree, fieldStructure, field);
     }
     /**
      * The function `validateJsonRTEFields` is used to validate the JSON RTE fields by checking if the
@@ -147,32 +201,18 @@ class Entries {
      * `EntryJsonRTEFieldDataType`, which represents a JSON RTE field in an entry. It contains properties
      * such as `uid`, `attrs`, and `children`.
      */
-    async validateJsonRTEFields(tree, fieldStructure, field) {
+    validateJsonRTEFields(tree, fieldStructure, field) {
         var _a;
+        // const missingRefIndex = []
         // NOTE Other possible reference logic will be added related to JSON RTE (Ex missing assets, extensions etc.,)
-        for (const child of (_a = field === null || field === void 0 ? void 0 : field.children) !== null && _a !== void 0 ? _a : []) {
-            const { uid: childrenUid, attrs, children } = child;
-            const { 'entry-uid': entryUid, 'content-type-uid': contentTypeUid } = attrs || {};
-            if (entryUid) {
-                const refExist = (0, find_1.default)(this.entryMetaData, { uid: entryUid });
-                if (!refExist) {
-                    tree.push({ field: 'children' }, { field: childrenUid, uid: fieldStructure.uid });
-                    this.missingRefs[this.currentUid].push({
-                        tree,
-                        uid: this.currentUid,
-                        name: this.currentTitle,
-                        data_type: fieldStructure.data_type,
-                        display_name: fieldStructure.display_name,
-                        treeStr: tree
-                            .map(({ name }) => name)
-                            .filter((val) => val)
-                            .join(' ➜ '),
-                        missingRefs: [{ uid: entryUid, 'content-type-uid': contentTypeUid }],
-                    });
-                }
+        for (const index in (_a = field === null || field === void 0 ? void 0 : field.children) !== null && _a !== void 0 ? _a : []) {
+            const child = field.children[index];
+            const { children } = child;
+            if (!this.fix) {
+                this.jsonRefCheck(tree, fieldStructure, child);
             }
             if (!(0, isEmpty_1.default)(children)) {
-                await this.validateJsonRTEFields(tree, fieldStructure, child);
+                this.validateJsonRTEFields(tree, fieldStructure, field.children[index]);
             }
         }
     }
@@ -189,15 +229,18 @@ class Entries {
      * @param {EntryModularBlocksDataType[]} field - The `field` parameter is an array of objects of type
      * `EntryModularBlocksDataType`.
      */
-    async validateModularBlocksField(tree, fieldStructure, field) {
-        const { blocks } = fieldStructure;
-        // NOTE Traverse each and every module and look for reference
-        for (let index = 0; index < blocks.length; index++) {
-            const ctBlock = blocks[index];
-            const entryBlock = field[index];
-            const { uid } = ctBlock;
-            if (entryBlock === null || entryBlock === void 0 ? void 0 : entryBlock[uid]) {
-                await this.lookForReference([...tree, { field: uid }], ctBlock, entryBlock[uid]);
+    validateModularBlocksField(tree, fieldStructure, field) {
+        if (!this.fix) {
+            for (const index in field) {
+                this.modularBlockRefCheck(tree, fieldStructure.blocks, field[index], +index);
+            }
+        }
+        for (const block of fieldStructure.blocks) {
+            const { uid, title } = block;
+            for (const eBlock of field) {
+                if (eBlock[uid]) {
+                    this.lookForReference([...tree, { uid, name: title }], block, eBlock[uid]);
+                }
             }
         }
     }
@@ -210,9 +253,16 @@ class Entries {
      * @param {EntryGroupFieldDataType} field - The `field` parameter is of type
      * `EntryGroupFieldDataType` and represents a single group field entry.
      */
-    async validateGroupField(tree, fieldStructure, field) {
+    validateGroupField(tree, fieldStructure, field) {
         // NOTE Any Group Field related logic can be added here (Ex data serialization or picking any metadata for report etc.,)
-        await this.lookForReference(tree, fieldStructure, field);
+        if (Array.isArray(field)) {
+            field.forEach((eGroup) => {
+                this.lookForReference([...tree, { uid: fieldStructure.uid, display_name: fieldStructure.display_name }], fieldStructure, eGroup);
+            });
+        }
+        else {
+            this.lookForReference(tree, fieldStructure, field);
+        }
     }
     /**
      * The function `validateReferenceValues` checks if the references in a given field exist in the
@@ -230,9 +280,12 @@ class Entries {
      * objects.
      */
     validateReferenceValues(tree, fieldStructure, field) {
+        if (this.fix)
+            return [];
         const missingRefs = [];
-        const { data_type, display_name } = fieldStructure;
-        for (const reference of field !== null && field !== void 0 ? field : []) {
+        const { uid: data_type, display_name } = fieldStructure;
+        for (const index in field !== null && field !== void 0 ? field : []) {
+            const reference = field[index];
             const { uid } = reference;
             // NOTE Can skip specific references keys (Ex, system defined keys can be skipped)
             // if (this.config.skipRefs.includes(reference)) continue;
@@ -258,6 +311,269 @@ class Entries {
             ]
             : [];
     }
+    /**
+     * The function `runFixOnSchema` takes in a tree, schema, and entry, and applies fixes to the entry
+     * based on the schema.
+     * @param {Record<string, unknown>[]} tree - An array of objects representing the tree structure of
+     * the schema. Each object has the following properties:
+     * @param {ContentTypeSchemaType[]} schema - The `schema` parameter is an array of objects
+     * representing the content type schema. Each object in the array contains information about a
+     * specific field in the schema, such as its unique identifier (`uid`) and data type (`data_type`).
+     * @param {EntryFieldType} entry - The `entry` parameter is of type `EntryFieldType`, which
+     * represents the data of an entry. It is an object that contains fields as key-value pairs, where
+     * the key is the field UID (unique identifier) and the value is the field data.
+     * @returns the updated `entry` object after applying fixes to the fields based on the provided
+     * `schema`.
+     */
+    runFixOnSchema(tree, schema, entry) {
+        // NOTE Global field Fix
+        schema.forEach((field) => {
+            const { uid, data_type } = field;
+            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]);
+                    break;
+                case 'json':
+                case 'reference':
+                    if (data_type === 'json') {
+                        if (field.field_metadata.extension) {
+                            // NOTE Custom field type
+                            break;
+                        }
+                        else if (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;
+                        }
+                    }
+                    // NOTE Reference field
+                    entry[uid] = this.fixMissingReferences([...tree, { uid: field.uid, name: field.display_name, data_type: field.data_type }], field, entry[uid]);
+                    break;
+                case 'blocks':
+                    entry[uid] = this.fixModularBlocksReferences([...tree, { uid: field.uid, name: field.display_name, data_type: field.data_type }], field.blocks, entry[uid]);
+                    break;
+                case 'group':
+                    entry[uid] = this.fixGroupField([...tree, { uid: field.uid, name: field.display_name, data_type: field.data_type }], field, entry[uid]);
+                    break;
+            }
+        });
+        return entry;
+    }
+    /**
+     * The function `fixGlobalFieldReferences` adds a new entry to a tree data structure and runs a fix
+     * on the schema.
+     * @param {Record<string, unknown>[]} tree - An array of objects representing the tree structure.
+     * @param {GlobalFieldDataType} field - The `field` parameter is of type `GlobalFieldDataType` and
+     * represents a global field object. It contains properties such as `uid` and `display_name`.
+     * @param {EntryGlobalFieldDataType} entry - The `entry` parameter is of type
+     * `EntryGlobalFieldDataType` and represents the global field entry that needs to be fixed.
+     * @returns the result of calling the `runFixOnSchema` method with the updated `tree` array,
+     * `field.schema`, and `entry` as arguments.
+     */
+    fixGlobalFieldReferences(tree, field, entry) {
+        return this.runFixOnSchema([...tree, { uid: field.uid, display_name: field.display_name }], field.schema, entry);
+    }
+    /**
+     * The function `fixModularBlocksReferences` takes in a tree, a list of blocks, and an entry, and
+     * performs various operations to fix references within the entry.
+     * @param {Record<string, unknown>[]} tree - An array of objects representing the tree structure of
+     * the modular blocks.
+     * @param {ModularBlockType[]} blocks - An array of objects representing modular blocks. Each object
+     * has properties like `uid` (unique identifier) and `title` (display name).
+     * @param {EntryModularBlocksDataType[]} entry - An array of objects representing the modular blocks
+     * data in an entry. Each object in the array represents a modular block and contains its unique
+     * identifier (uid) and other properties.
+     * @returns the updated `entry` array after performing some modifications.
+     */
+    fixModularBlocksReferences(tree, blocks, entry) {
+        entry = entry
+            .map((block, index) => this.modularBlockRefCheck(tree, blocks, block, index))
+            .filter((val) => !(0, isEmpty_1.default)(val));
+        blocks.forEach((block) => {
+            entry = entry
+                .map((eBlock) => {
+                if (!(0, isEmpty_1.default)(block.schema)) {
+                    if (eBlock[block.uid]) {
+                        eBlock[block.uid] = this.runFixOnSchema([...tree, { uid: block.uid, display_name: block.title }], block.schema, eBlock[block.uid]);
+                    }
+                }
+                return eBlock;
+            })
+                .filter((val) => !(0, isEmpty_1.default)(val));
+        });
+        return entry;
+    }
+    /**
+     * 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
+     * original entry.
+     * @param {Record<string, unknown>[]} tree - An array of objects representing the tree structure.
+     * @param {GroupFieldDataType} field - The `field` parameter is of type `GroupFieldDataType` and
+     * represents a group field object. It contains properties such as `uid` (unique identifier) and
+     * `display_name` (name of the field).
+     * @param {EntryGroupFieldDataType} entry - The `entry` parameter is of type
+     * `EntryGroupFieldDataType`.
+     * @returns If the `field.schema` is not empty, the function will return the result of calling
+     * `this.runFixOnSchema` with the updated `tree`, `field.schema`, and `entry` as arguments.
+     * Otherwise, it will return the `entry` as is.
+     */
+    fixGroupField(tree, field, entry) {
+        if (!(0, isEmpty_1.default)(field.schema)) {
+            if (Array.isArray(entry)) {
+                entry = entry.map((eGroup) => {
+                    return this.runFixOnSchema([...tree, { uid: field.uid, display_name: field.display_name }], field.schema, eGroup);
+                });
+            }
+            else {
+                entry = this.runFixOnSchema([...tree, { uid: field.uid, display_name: field.display_name }], field.schema, entry);
+            }
+        }
+        return entry;
+    }
+    /**
+     * The function fixes missing references in a JSON tree structure.
+     * @param {Record<string, unknown>[]} tree - An array of objects representing a tree structure. Each
+     * object in the array has a string key and an unknown value.
+     * @param {ReferenceFieldDataType | JsonRTEFieldDataType} field - The `field` parameter can be of
+     * type `ReferenceFieldDataType` or `JsonRTEFieldDataType`.
+     * @param {EntryJsonRTEFieldDataType} entry - The `entry` parameter is of type
+     * `EntryJsonRTEFieldDataType`, which represents an entry in a JSON Rich Text Editor (JsonRTE) field.
+     * @returns the updated `entry` object with fixed missing references in the `children` property.
+     */
+    fixJsonRteMissingReferences(tree, field, entry) {
+        if (Array.isArray(entry)) {
+            entry = entry.map((child, index) => {
+                return this.fixJsonRteMissingReferences([...tree, { index, type: child === null || child === void 0 ? void 0 : child.type, uid: child === null || child === void 0 ? void 0 : child.uid }], field, child);
+            });
+        }
+        else {
+            entry.children = entry.children
+                .map((child) => {
+                const refExist = this.jsonRefCheck(tree, field, child);
+                if (!refExist)
+                    return null;
+                if ((0, isEmpty_1.default)(child.children)) {
+                    child = this.fixJsonRteMissingReferences(tree, field, child);
+                }
+                return child;
+            })
+                .filter((val) => val);
+        }
+        return entry;
+    }
+    /**
+     * The `fixMissingReferences` function checks for missing references in an entry and adds them to a
+     * list if they are not found.
+     * @param {Record<string, unknown>[]} tree - An array of objects representing a tree structure. Each
+     * object in the array should have a "name" property and an optional "index" property.
+     * @param {ReferenceFieldDataType | JsonRTEFieldDataType} field - The `field` parameter is of type
+     * `ReferenceFieldDataType` or `JsonRTEFieldDataType`.
+     * @param {EntryReferenceFieldDataType[]} entry - The `entry` parameter is an array of objects that
+     * represent references to other entries. Each object in the array has the following properties:
+     * @returns the `entry` variable.
+     */
+    fixMissingReferences(tree, field, entry) {
+        const missingRefs = [];
+        entry = entry
+            .map((reference) => {
+            const { uid } = reference;
+            const refExist = (0, find_1.default)(this.entryMetaData, { uid });
+            if (!refExist) {
+                missingRefs.push(reference);
+                return null;
+            }
+            return reference;
+        })
+            .filter((val) => val);
+        if (!(0, isEmpty_1.default)(missingRefs)) {
+            this.missingRefs[this.currentUid].push({
+                tree,
+                fixStatus: 'Fixed',
+                uid: this.currentUid,
+                name: this.currentTitle,
+                data_type: field.data_type,
+                display_name: field.display_name,
+                treeStr: tree
+                    .map(({ name, index }) => (index || index === 0 ? `[${+index}].${name}` : name))
+                    .filter((val) => val)
+                    .join(' ➜ '),
+                missingRefs,
+            });
+        }
+        return entry;
+    }
+    /**
+     * The function `modularBlockRefCheck` checks for invalid keys in an entry block and returns the
+     * updated entry block.
+     * @param {Record<string, unknown>[]} tree - An array of objects representing the tree structure of
+     * the blocks.
+     * @param {ModularBlockType[]} blocks - The `blocks` parameter is an array of `ModularBlockType`
+     * objects.
+     * @param {EntryModularBlocksDataType} entryBlock - The `entryBlock` parameter is an object that
+     * represents a modular block entry. It contains key-value pairs where the keys are the UIDs of the
+     * modular blocks and the values are the data associated with each modular block.
+     * @param {Number} index - The `index` parameter is a number that represents the index of the current
+     * block in the `tree` array.
+     * @returns the `entryBlock` object.
+     */
+    modularBlockRefCheck(tree, blocks, entryBlock, index) {
+        const validBlockUid = blocks.map((block) => block.uid);
+        const invalidKeys = Object.keys(entryBlock).filter((key) => !validBlockUid.includes(key));
+        invalidKeys.forEach((key) => {
+            if (this.fix) {
+                delete entryBlock[key];
+            }
+            this.missingRefs[this.currentUid].push({
+                uid: this.currentUid,
+                name: this.currentTitle,
+                data_type: key,
+                display_name: key,
+                fixStatus: this.fix ? 'Fixed' : undefined,
+                tree: [...tree, { index, uid: key, name: key }],
+                treeStr: [...tree, { index, uid: key, name: key }]
+                    .map(({ name, index }) => (index || index === 0 ? `[${+index}].${name}` : name))
+                    .filter((val) => val)
+                    .join(' ➜ '),
+                missingRefs: [key],
+            });
+        });
+        return entryBlock;
+    }
+    /**
+     * The `jsonRefCheck` function checks if a reference exists in a JSON tree and adds missing
+     * references to a list if they are not found.
+     * @param {Record<string, unknown>[]} tree - An array of objects representing the tree structure.
+     * @param {JsonRTEFieldDataType} schema - The `schema` parameter is of type `JsonRTEFieldDataType`
+     * and represents the schema of a JSON field. It contains properties such as `uid`, `data_type`, and
+     * `display_name`.
+     * @param {EntryJsonRTEFieldDataType} child - The `child` parameter is an object that represents a
+     * child entry in a JSON tree. It has the following properties:
+     * @returns The function `jsonRefCheck` returns either `null` or `true`.
+     */
+    jsonRefCheck(tree, schema, child) {
+        const { uid: childrenUid } = child;
+        const { 'entry-uid': entryUid, 'content-type-uid': contentTypeUid } = child.attrs || {};
+        if (entryUid) {
+            const refExist = (0, find_1.default)(this.entryMetaData, { uid: entryUid });
+            if (!refExist) {
+                tree.push({ field: 'children' }, { field: childrenUid, uid: schema.uid });
+                this.missingRefs[this.currentUid].push({
+                    tree,
+                    uid: this.currentUid,
+                    name: this.currentTitle,
+                    data_type: schema.data_type,
+                    display_name: schema.display_name,
+                    fixStatus: this.fix ? 'Fixed' : undefined,
+                    treeStr: tree
+                        .map(({ name }) => name)
+                        .filter((val) => val)
+                        .join(' ➜ '),
+                    missingRefs: [{ uid: entryUid, 'content-type-uid': contentTypeUid }],
+                });
+                return null;
+            }
+        }
+        return true;
+    }
     /**
      * The function prepares entry metadata by reading and processing files from different locales and
      * schemas.
@@ -267,8 +583,8 @@ 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, 'utf-8')));
-        this.locales.push(...(0, values_1.default)(JSON.parse((0, fs_1.readFileSync)(localesPath, 'utf-8'))));
+        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'))));
         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/content-types.d.ts

@@ -1,13 +1,15 @@
 import config from '../config';
 import { ConfigType, LogFn } from './utils';
+type ContentTypeSchemaType = ReferenceFieldDataType | GlobalFieldDataType | CustomFieldDataType | JsonRTEFieldDataType | GroupFieldDataType | ModularBlocksDataType;
 type ContentTypeStruct = {
     uid: string;
     title: string;
     description: string;
-    schema?: (ReferenceFieldDataType | GlobalFieldDataType | CustomFieldDataType | JsonRTEFieldDataType | GroupFieldDataType | ModularBlocksDataType)[];
+    schema?: ContentTypeSchemaType[];
 };
 type ModuleConstructorParam = {
     log: LogFn;
+    fix?: boolean;
     config: ConfigType;
     moduleName?: keyof typeof config.moduleConfig;
 };
@@ -30,6 +32,7 @@ type RefErrorReturnType = {
     ct_uid: string;
     treeStr: string;
     data_type: string;
+    fixStatus?: string;
     missingRefs: string[];
     display_name: string;
     tree: Record<string, unknown>[];
@@ -38,10 +41,13 @@ type ReferenceFieldDataType = CommonDataTypeStruct & {
     reference_to: string[];
 };
 type GlobalFieldDataType = CommonDataTypeStruct & {
-    reference_to: string;
+    reference_to?: string;
     schema: GlobalFieldSchemaTypes[];
 };
-type CustomFieldDataType = CommonDataTypeStruct & {};
+type CustomFieldDataType = CommonDataTypeStruct & {
+    reference_to: string[];
+    extension_uid: string;
+};
 type JsonRTEFieldDataType = CommonDataTypeStruct & {
     reference_to: string[];
 };
@@ -51,6 +57,7 @@ type GroupFieldDataType = CommonDataTypeStruct & {
 type ModularBlockType = {
     uid: string;
     title: string;
+    reference_to?: string;
     schema: (JsonRTEFieldDataType | ModularBlocksDataType | ReferenceFieldDataType | CustomFieldDataType | GroupFieldDataType)[];
 };
 type ModularBlocksDataType = CommonDataTypeStruct & {
@@ -66,4 +73,4 @@ declare enum OutputColumn {
     'Missing references' = "missingRefs",
     Path = "treeStr"
 }
-export { CtConstructorParam, ContentTypeStruct, ModuleConstructorParam, ReferenceFieldDataType, GlobalFieldDataType, CustomFieldDataType, JsonRTEFieldDataType, GroupFieldDataType, ModularBlocksDataType, RefErrorReturnType, ModularBlocksSchemaTypes, ModularBlockType, OutputColumn, };
+export { CtConstructorParam, ContentTypeStruct, ModuleConstructorParam, ReferenceFieldDataType, GlobalFieldDataType, CustomFieldDataType, JsonRTEFieldDataType, GroupFieldDataType, ModularBlocksDataType, RefErrorReturnType, ModularBlocksSchemaTypes, ModularBlockType, OutputColumn, ContentTypeSchemaType, };

package/lib/types/entries.d.ts

@@ -25,8 +25,9 @@ type EntryJsonRTEFieldDataType = {
     attrs: Record<string, any>;
     children: EntryJsonRTEFieldDataType[];
 };
+type GroupFieldType = EntryReferenceFieldDataType[] | EntryGlobalFieldDataType | EntryJsonRTEFieldDataType;
 type EntryGroupFieldDataType = {
-    [key: string]: EntryReferenceFieldDataType[] | EntryGlobalFieldDataType | EntryJsonRTEFieldDataType;
+    [key: string]: GroupFieldType;
 };
 type EntryModularBlockType = {
     [key: string]: EntryJsonRTEFieldDataType | EntryModularBlocksDataType | EntryReferenceFieldDataType[] | EntryGroupFieldDataType;
@@ -39,8 +40,10 @@ type EntryRefErrorReturnType = {
     uid: string;
     treeStr: string;
     data_type: string;
-    missingRefs: string[] | Record<string, unknown>[];
+    fixStatus?: string;
     display_name: string;
     tree: Record<string, unknown>[];
+    missingRefs: string[] | Record<string, unknown>[];
 };
-export { Locale, EntryStruct, EntryGlobalFieldDataType, EntryCustomFieldDataType, EntryJsonRTEFieldDataType, EntryGroupFieldDataType, EntryModularBlocksDataType, EntryReferenceFieldDataType, EntryRefErrorReturnType, };
+type EntryFieldType = EntryStruct | EntryGlobalFieldDataType | EntryModularBlocksDataType | EntryGroupFieldDataType;
+export { Locale, EntryStruct, EntryFieldType, EntryGlobalFieldDataType, EntryCustomFieldDataType, EntryJsonRTEFieldDataType, EntryGroupFieldDataType, EntryModularBlocksDataType, EntryReferenceFieldDataType, EntryRefErrorReturnType, GroupFieldType, EntryModularBlockType, };