@contentstack/cli-audit 1.0.0 → 1.2.0

package/lib/modules/content-types.js

@@ -1,19 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-const path_1 = require("path");
 const find_1 = tslib_1.__importDefault(require("lodash/find"));
+const core_1 = require("@oclif/core");
+const isEmpty_1 = tslib_1.__importDefault(require("lodash/isEmpty"));
+const path_1 = require("path");
 const fs_1 = require("fs");
 const messages_1 = require("../messages");
 /* The `ContentType` class is responsible for scanning content types, looking for references, and
 generating a report in JSON and CSV formats. */
 class ContentType {
-    constructor({ log, config, moduleName, ctSchema, gfSchema }) {
+    constructor({ log, fix, config, moduleName, ctSchema, gfSchema }) {
         this.schema = [];
         this.missingRefs = {};
-        this.moduleName = 'content-types';
         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 : 'content-types';
@@ -25,7 +27,7 @@ class ContentType {
      * iterates over the schema and looks for references, and returns a list of missing references.
      * @returns the `missingRefs` object.
      */
-    async run() {
+    async run(returnFixSchema = false) {
         var _a;
         if (!(0, fs_1.existsSync)(this.folderPath)) {
             throw new Error((0, messages_1.$t)(messages_1.auditMsg.NOT_VALID_PATH, { path: this.folderPath }));
@@ -39,6 +41,12 @@ class ContentType {
             await this.lookForReference([{ uid, name: title }], schema);
             this.log((0, messages_1.$t)(messages_1.auditMsg.SCAN_CT_SUCCESS_MSG, { title, module: this.config.moduleConfig[this.moduleName].name }), 'info');
         }
+        if (returnFixSchema) {
+            return this.schema;
+        }
+        if (this.fix) {
+            await this.writeFixContent();
+        }
         for (let propName in this.missingRefs) {
             if (!this.missingRefs[propName].length) {
                 delete this.missingRefs[propName];
@@ -46,6 +54,19 @@ class ContentType {
         }
         return this.missingRefs;
     }
+    /**
+     * 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() {
+        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)((0, path_1.join)(this.folderPath, this.config.moduleConfig[this.moduleName].fileName), JSON.stringify(this.schema));
+        }
+    }
     /**
      * The function `lookForReference` iterates through a given schema and performs validation checks
      * based on the data type of each field.
@@ -57,29 +78,33 @@ class ContentType {
      * `tree`: An array of objects representing the tree structure of the content type or field. Each
      * object in the array should have a `uid` and `name` property.
      */
-    async lookForReference(tree, { schema }) {
-        for (const field of schema !== null && schema !== void 0 ? schema : []) {
-            switch (field.data_type) {
+    async lookForReference(tree, field) {
+        var _a;
+        if (this.fix) {
+            field.schema = this.runFixOnSchema(tree, field.schema);
+        }
+        for (let child of (_a = field.schema) !== null && _a !== void 0 ? _a : []) {
+            switch (child.data_type) {
                 case 'reference':
-                    this.missingRefs[this.currentUid].push(...this.validateReferenceField([...tree, { uid: field.uid, name: field.display_name }], field));
+                    this.missingRefs[this.currentUid].push(...this.validateReferenceField([...tree, { uid: field.uid, name: child.display_name }], child));
                     break;
                 case 'global_field':
-                    await this.validateGlobalField([...tree, { uid: field.uid, name: field.display_name }], field);
+                    await this.validateGlobalField([...tree, { uid: child.uid, name: child.display_name }], child);
                     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
-                        this.missingRefs[this.currentUid].push(...this.validateJsonRTEFields([...tree, { uid: field.uid, name: field.display_name }], field));
+                        this.missingRefs[this.currentUid].push(...this.validateJsonRTEFields([...tree, { uid: child.uid, name: child.display_name }], child));
                     }
                     break;
                 case 'blocks':
-                    await this.validateModularBlocksField([...tree, { uid: field.uid, name: field.display_name }], field);
+                    await this.validateModularBlocksField([...tree, { uid: child.uid, name: child.display_name }], child);
                     break;
                 case 'group':
-                    await this.validateGroupField([...tree, { uid: field.uid, name: field.display_name }], field);
+                    await this.validateGroupField([...tree, { uid: child.uid, name: child.display_name }], child);
                     break;
             }
         }
@@ -106,22 +131,6 @@ class ContentType {
      */
     async validateGlobalField(tree, field) {
         // NOTE Any GlobalField related logic can be added here
-        const missingRefs = [];
-        const { reference_to, display_name, data_type } = field;
-        if (!(0, find_1.default)(this.gfSchema, { uid: reference_to })) {
-            missingRefs.push(reference_to);
-        }
-        if (missingRefs.length) {
-            this.missingRefs[this.currentUid].push({
-                tree,
-                data_type,
-                missingRefs,
-                display_name,
-                ct_uid: this.currentUid,
-                name: this.currentTitle,
-                treeStr: tree.map(({ name }) => name).join(' ➜ '),
-            });
-        }
         await this.lookForReference(tree, field);
     }
     /**
@@ -149,7 +158,7 @@ class ContentType {
      */
     async validateModularBlocksField(tree, field) {
         const { blocks } = field;
-        // NOTE Traverse each and every module and look for reference
+        this.fixModularBlocksReferences(tree, blocks);
         for (const block of blocks) {
             const { uid, title } = block;
             await this.lookForReference([...tree, { uid, name: title }], block);
@@ -180,8 +189,10 @@ class ContentType {
      * objects.
      */
     validateReferenceToValues(tree, field) {
+        if (this.fix)
+            return [];
         const missingRefs = [];
-        const { reference_to, display_name, data_type } = field;
+        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))
@@ -200,10 +211,207 @@ class ContentType {
                     display_name,
                     ct_uid: this.currentUid,
                     name: this.currentTitle,
-                    treeStr: tree.map(({ name }) => name).join(' ➜ '),
+                    treeStr: tree
+                        .map(({ name }) => name)
+                        .filter((val) => val)
+                        .join(' ➜ '),
                 },
             ]
             : [];
     }
+    /**
+     * The function `runFixOnSchema` takes in a tree and a schema, and performs various fixes on the
+     * schema based on the data types of the fields.
+     * @param {Record<string, unknown>[]} tree - An array of objects representing the tree structure of
+     * the schema.
+     * @param {ContentTypeSchemaType[]} schema - The `schema` parameter is an array of
+     * `ContentTypeSchemaType` objects. Each object represents a field in a content type schema and
+     * contains properties such as `data_type`, `field_metadata`, `uid`, `name`, etc.
+     * @returns an array of ContentTypeSchemaType objects.
+     */
+    runFixOnSchema(tree, schema) {
+        // NOTE Global field Fix
+        return schema
+            .map((field) => {
+            const { data_type } = field;
+            switch (data_type) {
+                case 'global_field':
+                    return this.fixGlobalFieldReferences(tree, field);
+                case 'json':
+                case 'reference':
+                    if (data_type === 'json') {
+                        if (field.field_metadata.extension) {
+                            // NOTE Custom field type
+                            return field;
+                        }
+                        else if (field.field_metadata.allow_json_rte) {
+                            return this.fixMissingReferences(tree, field);
+                        }
+                    }
+                    return this.fixMissingReferences(tree, field);
+                case 'blocks':
+                    field.blocks = this.fixModularBlocksReferences([...tree, { uid: field.uid, name: field.display_name, data_type: field.data_type }], field.blocks);
+                    if ((0, isEmpty_1.default)(field.blocks)) {
+                        return null;
+                    }
+                    return field;
+                case 'group':
+                    return this.fixGroupField(tree, field);
+                default:
+                    return field;
+            }
+        })
+            .filter((val) => {
+            if ((val === null || val === void 0 ? void 0 : val.schema) && (0, isEmpty_1.default)(val.schema))
+                return false;
+            if ((val === null || val === void 0 ? void 0 : val.reference_to) && (0, isEmpty_1.default)(val.reference_to))
+                return false;
+            return !!val;
+        });
+    }
+    /**
+     * The function fixes global field references in a tree structure by adding missing references and
+     * returning the field if the reference exists, otherwise returning null.
+     * @param {Record<string, unknown>[]} tree - An array of objects representing a tree structure.
+     * @param {GlobalFieldDataType} field - The `field` parameter is an object that represents a global
+     * field. It has the following properties:
+     * @returns either the `field` object if `reference_to` exists in `this.gfSchema`, or `null` if it
+     * doesn't.
+     */
+    fixGlobalFieldReferences(tree, field) {
+        const { reference_to, display_name, data_type } = field;
+        if (reference_to && data_type === 'global_field') {
+            tree = [...tree, { uid: field.uid, name: field.display_name, data_type: field.data_type }];
+            const refExist = (0, find_1.default)(this.gfSchema, { uid: reference_to });
+            if (!refExist) {
+                this.missingRefs[this.currentUid].push({
+                    tree,
+                    data_type,
+                    display_name,
+                    fixStatus: 'Fixed',
+                    missingRefs: [reference_to],
+                    ct_uid: this.currentUid,
+                    name: this.currentTitle,
+                    treeStr: tree.map(({ name }) => name).join(' ➜ '),
+                });
+            }
+            return refExist ? field : null;
+        }
+        return field;
+    }
+    /**
+     * The function `fixModularBlocksReferences` takes in an array of tree objects and an array of
+     * modular blocks, and returns an array of modular blocks with fixed references.
+     * @param {Record<string, unknown>[]} tree - An array of objects representing the tree structure.
+     * @param {ModularBlockType[]} blocks - An array of objects representing modular blocks. Each object
+     * has properties such as "reference_to", "schema", "title", and "uid".
+     * @returns an array of `ModularBlockType` objects.
+     */
+    fixModularBlocksReferences(tree, blocks) {
+        return blocks
+            .map((block) => {
+            const { reference_to, schema, title: display_name } = block;
+            tree = [...tree, { uid: block.uid, name: block.title }];
+            const refErrorObj = {
+                tree,
+                display_name,
+                fixStatus: 'Fixed',
+                missingRefs: [reference_to],
+                ct_uid: this.currentUid,
+                name: this.currentTitle,
+                treeStr: tree.map(({ name }) => name).join(' ➜ '),
+            };
+            if (!schema) {
+                this.missingRefs[this.currentUid].push(refErrorObj);
+                return false;
+            }
+            // NOTE Global field section
+            if (reference_to) {
+                const refExist = (0, find_1.default)(this.gfSchema, { uid: reference_to });
+                if (!refExist) {
+                    this.missingRefs[this.currentUid].push(refErrorObj);
+                }
+                return refExist;
+            }
+            block.schema = this.runFixOnSchema(tree, block.schema);
+            if ((0, isEmpty_1.default)(block.schema)) {
+                this.missingRefs[this.currentUid].push(Object.assign(Object.assign({}, refErrorObj), { missingRefs: 'Empty schema found', treeStr: tree.map(({ name }) => name).join(' ➜ ') }));
+                this.log((0, messages_1.$t)(messages_1.auditFixMsg.EMPTY_FIX_MSG, { path: tree.map(({ name }) => name).join(' ➜ ') }), 'info');
+                return null;
+            }
+            return block;
+        })
+            .filter((val) => val);
+    }
+    /**
+     * 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.
+     * @param {Record<string, unknown>[]} tree - An array of objects representing a tree structure. Each
+     * object in the array should have a "name" property.
+     * @param {ReferenceFieldDataType | JsonRTEFieldDataType} field - The `field` parameter is of type
+     * `ReferenceFieldDataType` or `JsonRTEFieldDataType`.
+     * @returns the `field` object.
+     */
+    fixMissingReferences(tree, field) {
+        let fixStatus;
+        const missingRefs = [];
+        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))
+                continue;
+            const refExist = (0, find_1.default)(this.ctSchema, { uid: reference });
+            if (!refExist) {
+                missingRefs.push(reference);
+            }
+        }
+        if (this.fix && !(0, isEmpty_1.default)(missingRefs)) {
+            try {
+                field.reference_to = field.reference_to.filter((ref) => !missingRefs.includes(ref));
+                fixStatus = 'Fixed';
+            }
+            catch (error) {
+                fixStatus = `Not Fixed (${JSON.stringify(error)})`;
+            }
+            this.missingRefs[this.currentUid].push({
+                tree,
+                data_type,
+                fixStatus,
+                missingRefs,
+                display_name,
+                ct_uid: this.currentUid,
+                name: this.currentTitle,
+                treeStr: tree.map(({ name }) => name).join(' ➜ '),
+            });
+        }
+        return field;
+    }
+    /**
+     * The function `fixGroupField` takes in an array of objects and a field, and performs some
+     * operations on the field's schema property.
+     * @param {Record<string, unknown>[]} tree - An array of objects representing a tree structure.
+     * @param {GroupFieldDataType} field - The `field` parameter is an object that contains the following
+     * properties:
+     * @returns The function `fixGroupField` returns either `null` or the `field` object.
+     */
+    fixGroupField(tree, field) {
+        const { data_type, display_name } = field;
+        field.schema = this.runFixOnSchema(tree, field.schema);
+        if ((0, isEmpty_1.default)(field.schema)) {
+            this.missingRefs[this.currentUid].push({
+                tree,
+                data_type,
+                display_name,
+                fixStatus: 'Fixed',
+                ct_uid: this.currentUid,
+                name: this.currentTitle,
+                missingRefs: 'Empty schema found',
+                treeStr: tree.map(({ name }) => name).join(' ➜ '),
+            });
+            this.log((0, messages_1.$t)(messages_1.auditFixMsg.EMPTY_FIX_MSG, { path: tree.map(({ name }) => name).join(' ➜ ') }), 'info');
+            return null;
+        }
+        return field;
+    }
 }
 exports.default = ContentType;

package/lib/modules/entries.d.ts

@@ -1,7 +1,8 @@
-import { LogFn, Locale, ConfigType, EntryStruct, ModularBlockType, ContentTypeStruct, CtConstructorParam, GroupFieldDataType, GlobalFieldDataType, JsonRTEFieldDataType, ModularBlocksDataType, ModuleConstructorParam, ReferenceFieldDataType, EntryRefErrorReturnType, EntryGroupFieldDataType, EntryGlobalFieldDataType, EntryJsonRTEFieldDataType, EntryModularBlocksDataType, EntryReferenceFieldDataType } from '../types';
 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';
 export default class Entries {
     log: LogFn;
+    private fix;
     fileName: string;
     locales: Locale[];
     config: ConfigType;
@@ -10,16 +11,22 @@ export default class Entries {
     currentTitle: string;
     gfSchema: ContentTypeStruct[];
     ctSchema: ContentTypeStruct[];
+    private entries;
     protected missingRefs: Record<string, any>;
     entryMetaData: Record<string, any>[];
     moduleName: keyof typeof auditConfig.moduleConfig;
-    constructor({ log, config, moduleName, ctSchema, gfSchema }: ModuleConstructorParam & CtConstructorParam);
+    constructor({ log, fix, config, moduleName, ctSchema, gfSchema }: ModuleConstructorParam & CtConstructorParam);
     /**
      * The `run` function checks if a folder path exists, sets the schema based on the module name,
      * iterates over the schema and looks for references, and returns a list of missing references.
      * @returns the `missingRefs` object.
      */
     run(): Promise<Record<string, any>>;
+    /**
+     * The function checks if it can write the fix content to a file and if so, it writes the content as
+     * JSON to the specified file path.
+     */
+    writeFixContent(filePath: string, schema: Record<string, EntryStruct>): Promise<void>;
     /**
      * The function `lookForReference` iterates over a given schema and validates different field types
      * such as reference, global field, JSON, modular blocks, and group fields.
@@ -32,7 +39,7 @@ export default 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.
      */
-    lookForReference(tree: Record<string, unknown>[], { schema }: ContentTypeStruct | GlobalFieldDataType | ModularBlockType | GroupFieldDataType, entry: EntryStruct | EntryGlobalFieldDataType | EntryModularBlocksDataType | EntryGroupFieldDataType): Promise<void>;
+    lookForReference(tree: Record<string, unknown>[], field: ContentTypeStruct | GlobalFieldDataType | ModularBlockType | GroupFieldDataType, entry: EntryFieldType): void;
     /**
      * The function `validateReferenceField` validates the reference values of a given field in a tree
      * structure.
@@ -59,7 +66,7 @@ export default class Entries {
      * @param {EntryGlobalFieldDataType} field - The `field` parameter is of type
      * `EntryGlobalFieldDataType`. It represents a single global field entry.
      */
-    validateGlobalField(tree: Record<string, unknown>[], fieldStructure: GlobalFieldDataType, field: EntryGlobalFieldDataType): Promise<void>;
+    validateGlobalField(tree: Record<string, unknown>[], fieldStructure: GlobalFieldDataType, field: EntryGlobalFieldDataType): void;
     /**
      * The function `validateJsonRTEFields` is used to validate the JSON RTE fields by checking if the
      * referenced entries exist and adding missing references to a tree structure.
@@ -72,7 +79,7 @@ export default class Entries {
      * `EntryJsonRTEFieldDataType`, which represents a JSON RTE field in an entry. It contains properties
      * such as `uid`, `attrs`, and `children`.
      */
-    validateJsonRTEFields(tree: Record<string, unknown>[], fieldStructure: JsonRTEFieldDataType, field: EntryJsonRTEFieldDataType): Promise<void>;
+    validateJsonRTEFields(tree: Record<string, unknown>[], fieldStructure: JsonRTEFieldDataType, field: EntryJsonRTEFieldDataType): void;
     /**
      * The function validates the modular blocks field by traversing each module and looking for
      * references.
@@ -86,7 +93,7 @@ export default class Entries {
      * @param {EntryModularBlocksDataType[]} field - The `field` parameter is an array of objects of type
      * `EntryModularBlocksDataType`.
      */
-    validateModularBlocksField(tree: Record<string, unknown>[], fieldStructure: ModularBlocksDataType, field: EntryModularBlocksDataType[]): Promise<void>;
+    validateModularBlocksField(tree: Record<string, unknown>[], fieldStructure: ModularBlocksDataType, field: EntryModularBlocksDataType[]): void;
     /**
      * The function validates a group field by looking for a reference in a tree structure.
      * @param {Record<string, unknown>[]} tree - An array of objects representing the tree structure.
@@ -96,7 +103,7 @@ export default class Entries {
      * @param {EntryGroupFieldDataType} field - The `field` parameter is of type
      * `EntryGroupFieldDataType` and represents a single group field entry.
      */
-    validateGroupField(tree: Record<string, unknown>[], fieldStructure: GroupFieldDataType, field: EntryGroupFieldDataType): Promise<void>;
+    validateGroupField(tree: Record<string, unknown>[], fieldStructure: GroupFieldDataType, field: EntryGroupFieldDataType | EntryGroupFieldDataType[]): void;
     /**
      * The function `validateReferenceValues` checks if the references in a given field exist in the
      * provided tree and returns any missing references.
@@ -113,6 +120,111 @@ export default class Entries {
      * objects.
      */
     validateReferenceValues(tree: Record<string, unknown>[], fieldStructure: ReferenceFieldDataType, field: EntryReferenceFieldDataType[]): EntryRefErrorReturnType[];
+    /**
+     * 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: Record<string, unknown>[], schema: ContentTypeSchemaType[], entry: EntryFieldType): EntryFieldType;
+    /**
+     * 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: Record<string, unknown>[], field: GlobalFieldDataType, entry: EntryGlobalFieldDataType): EntryFieldType;
+    /**
+     * 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: Record<string, unknown>[], blocks: ModularBlockType[], entry: EntryModularBlocksDataType[]): EntryModularBlocksDataType[];
+    /**
+     * 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: Record<string, unknown>[], field: GroupFieldDataType, entry: EntryGroupFieldDataType | EntryGroupFieldDataType[]): EntryGroupFieldDataType | EntryGroupFieldDataType[];
+    /**
+     * 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: Record<string, unknown>[], field: ReferenceFieldDataType | JsonRTEFieldDataType, entry: EntryJsonRTEFieldDataType | EntryJsonRTEFieldDataType[]): EntryJsonRTEFieldDataType | EntryJsonRTEFieldDataType[];
+    /**
+     * 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: Record<string, unknown>[], field: ReferenceFieldDataType | JsonRTEFieldDataType, entry: EntryReferenceFieldDataType[]): EntryReferenceFieldDataType[];
+    /**
+     * 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: Record<string, unknown>[], blocks: ModularBlockType[], entryBlock: EntryModularBlocksDataType, index: Number): EntryModularBlocksDataType;
+    /**
+     * 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: Record<string, unknown>[], schema: JsonRTEFieldDataType, child: EntryJsonRTEFieldDataType): true | null;
     /**
      * The function prepares entry metadata by reading and processing files from different locales and
      * schemas.