@contentstack/cli-audit 1.0.0

package/lib/modules/content-types.js

@@ -0,0 +1,209 @@
+"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 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 }) {
+        this.schema = [];
+        this.missingRefs = {};
+        this.moduleName = 'content-types';
+        this.log = log;
+        this.config = config;
+        this.ctSchema = ctSchema;
+        this.gfSchema = gfSchema;
+        this.moduleName = moduleName !== null && moduleName !== void 0 ? moduleName : 'content-types';
+        this.fileName = config.moduleConfig[this.moduleName].fileName;
+        this.folderPath = (0, path_1.resolve)(config.basePath, config.moduleConfig[this.moduleName].dirName);
+    }
+    /**
+     * The `run` function checks if a folder path exists, sets the schema based on the module name,
+     * iterates over the schema and looks for references, and returns a list of missing references.
+     * @returns the `missingRefs` object.
+     */
+    async run() {
+        var _a;
+        if (!(0, fs_1.existsSync)(this.folderPath)) {
+            throw new Error((0, messages_1.$t)(messages_1.auditMsg.NOT_VALID_PATH, { path: this.folderPath }));
+        }
+        this.schema = this.moduleName === 'content-types' ? this.ctSchema : this.gfSchema;
+        for (const schema of (_a = this.schema) !== null && _a !== void 0 ? _a : []) {
+            this.currentUid = schema.uid;
+            this.currentTitle = schema.title;
+            this.missingRefs[this.currentUid] = [];
+            const { uid, title } = schema;
+            await this.lookForReference([{ uid, name: title }], schema);
+            this.log((0, messages_1.$t)(messages_1.auditMsg.SCAN_CT_SUCCESS_MSG, { title, module: this.config.moduleConfig[this.moduleName].name }), 'info');
+        }
+        for (let propName in this.missingRefs) {
+            if (!this.missingRefs[propName].length) {
+                delete this.missingRefs[propName];
+            }
+        }
+        return this.missingRefs;
+    }
+    /**
+     * The function `lookForReference` iterates through a given schema and performs validation checks
+     * based on the data type of each field.
+     * @param {Record<string, unknown>[]} tree - An array of objects representing the tree structure of
+     * the content type or field being validated. Each object in the array should have a "uid" property
+     * representing the unique identifier of the content type or field, and a "name" property
+     * representing the display name of the content type or field.
+     * @param {ContentTypeStruct | GlobalFieldDataType | ModularBlockType | GroupFieldDataType}  - -
+     * `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) {
+                case 'reference':
+                    this.missingRefs[this.currentUid].push(...this.validateReferenceField([...tree, { uid: field.uid, name: field.display_name }], field));
+                    break;
+                case 'global_field':
+                    await this.validateGlobalField([...tree, { uid: field.uid, name: field.display_name }], field);
+                    break;
+                case 'json':
+                    if (field.field_metadata.extension) {
+                        // NOTE Custom field type
+                    }
+                    else if (field.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));
+                    }
+                    break;
+                case 'blocks':
+                    await this.validateModularBlocksField([...tree, { uid: field.uid, name: field.display_name }], field);
+                    break;
+                case 'group':
+                    await this.validateGroupField([...tree, { uid: field.uid, name: field.display_name }], field);
+                    break;
+            }
+        }
+    }
+    /**
+     * The function validates a reference field in a tree data structure.
+     * @param {Record<string, unknown>[]} tree - The "tree" parameter is an array of objects, where each
+     * object represents a node in a tree-like structure. Each object can have multiple properties, and
+     * the structure of the tree is defined by the relationships between these properties.
+     * @param {ReferenceFieldDataType} field - The `field` parameter is of type `ReferenceFieldDataType`.
+     * @returns an array of RefErrorReturnType.
+     */
+    validateReferenceField(tree, field) {
+        return this.validateReferenceToValues(tree, field);
+    }
+    /**
+     * The function "validateGlobalField" asynchronously validates a global field by looking for a
+     * reference in a tree data structure.
+     * @param {Record<string, unknown>[]} tree - The `tree` parameter is an array of objects. Each object
+     * represents a node in a tree structure. The tree structure can be represented as a hierarchical
+     * structure where each object can have child nodes.
+     * @param {GlobalFieldDataType} field - The `field` parameter is of type `GlobalFieldDataType`. It
+     * represents the field that needs to be validated.
+     */
+    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);
+    }
+    /**
+     * The function validates the reference to values in a JSON RTE field.
+     * @param {Record<string, unknown>[]} tree - The "tree" parameter is an array of objects where each
+     * object represents a node in a tree-like structure. Each object can have multiple key-value pairs,
+     * where the key is a string and the value can be of any type.
+     * @param {JsonRTEFieldDataType} field - The `field` parameter is of type `JsonRTEFieldDataType`.
+     * @returns The function `validateJsonRTEFields` is returning an array of `RefErrorReturnType`
+     * objects.
+     */
+    validateJsonRTEFields(tree, field) {
+        // NOTE Other possible reference logic will be added related to JSON RTE (Ex missing assets, extensions etc.,)
+        return this.validateReferenceToValues(tree, field);
+    }
+    /**
+     * The function validates the modular blocks field by traversing each module and looking for
+     * references.
+     * @param {Record<string, unknown>[]} tree - An array of objects representing the tree structure of
+     * the modular blocks. Each object in the array represents a node in the tree and contains properties
+     * like "uid" and "name".
+     * @param {ModularBlocksDataType} field - The `field` parameter is of type `ModularBlocksDataType`.
+     * It represents a modular blocks field and contains an array of blocks. Each block has properties
+     * like `uid` and `title`.
+     */
+    async validateModularBlocksField(tree, field) {
+        const { blocks } = field;
+        // NOTE Traverse each and every module and look for reference
+        for (const block of blocks) {
+            const { uid, title } = block;
+            await this.lookForReference([...tree, { uid, name: title }], block);
+        }
+    }
+    /**
+     * The function `validateGroupField` is an asynchronous function that validates a group field by
+     * looking for a reference in a tree data structure.
+     * @param {Record<string, unknown>[]} tree - The `tree` parameter is an array of objects that
+     * represents a tree structure. Each object in the array represents a node in the tree, and it
+     * contains key-value pairs where the keys are field names and the values are the corresponding field
+     * values.
+     * @param {GroupFieldDataType} field - The `field` parameter is of type `GroupFieldDataType`. It
+     * represents the group field that needs to be validated.
+     */
+    async validateGroupField(tree, 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, field);
+    }
+    /**
+     * The function `validateReferenceToValues` checks if all the references specified in a field exist
+     * in a given tree of records and returns any missing references.
+     * @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 an object
+     * that represents a reference field in a content type. It has the following properties:
+     * @returns The function `validateReferenceToValues` returns an array of `RefErrorReturnType`
+     * objects.
+     */
+    validateReferenceToValues(tree, field) {
+        const missingRefs = [];
+        const { 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))
+                continue;
+            const refExist = (0, find_1.default)(this.ctSchema, { uid: reference });
+            if (!refExist) {
+                missingRefs.push(reference);
+            }
+        }
+        return missingRefs.length
+            ? [
+                {
+                    tree,
+                    data_type,
+                    missingRefs,
+                    display_name,
+                    ct_uid: this.currentUid,
+                    name: this.currentTitle,
+                    treeStr: tree.map(({ name }) => name).join(' ➜ '),
+                },
+            ]
+            : [];
+    }
+}
+exports.default = ContentType;

package/lib/modules/entries.d.ts

@@ -0,0 +1,121 @@
+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';
+export default class Entries {
+    log: LogFn;
+    fileName: string;
+    locales: Locale[];
+    config: ConfigType;
+    folderPath: string;
+    currentUid: string;
+    currentTitle: string;
+    gfSchema: ContentTypeStruct[];
+    ctSchema: ContentTypeStruct[];
+    protected missingRefs: Record<string, any>;
+    entryMetaData: Record<string, any>[];
+    moduleName: keyof typeof auditConfig.moduleConfig;
+    constructor({ log, 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 `lookForReference` iterates over a given schema and validates different field types
+     * such as reference, global field, JSON, modular blocks, and group fields.
+     * @param {Record<string, unknown>[]} tree - An array of objects representing the tree structure of
+     * the content type or field being validated. Each object in the array has the following properties:
+     * @param {ContentTypeStruct | GlobalFieldDataType | ModularBlockType | GroupFieldDataType}  - -
+     * `tree`: An array of objects representing the tree structure of the content type or field being
+     * validated.
+     * @param {EntryStruct | EntryGlobalFieldDataType | EntryModularBlocksDataType |
+     * 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>;
+    /**
+     * The function `validateReferenceField` validates the reference values of a given field in a tree
+     * structure.
+     * @param {Record<string, unknown>[]} tree - An array of objects representing a tree structure. Each
+     * object in the array should have a unique identifier field.
+     * @param {ReferenceFieldDataType} fieldStructure - The `fieldStructure` parameter is of type
+     * `ReferenceFieldDataType`. It represents the structure of the reference field that needs to be
+     * validated.
+     * @param {EntryReferenceFieldDataType[]} field - The `field` parameter is an array of
+     * `EntryReferenceFieldDataType` objects.
+     * @returns the result of calling the `validateReferenceValues` function with the provided arguments
+     * `tree`, `fieldStructure`, and `field`.
+     */
+    validateReferenceField(tree: Record<string, unknown>[], fieldStructure: ReferenceFieldDataType, field: EntryReferenceFieldDataType[]): EntryRefErrorReturnType[];
+    /**
+     * The function "validateGlobalField" is an asynchronous function that takes in a tree,
+     * fieldStructure, and field as parameters and looks for references in the tree.
+     * @param {Record<string, unknown>[]} tree - The `tree` parameter is an array of objects. Each object
+     * represents a node in a tree structure. The tree structure can be represented as a hierarchical
+     * structure where each object can have child objects.
+     * @param {GlobalFieldDataType} fieldStructure - The `fieldStructure` parameter is of type
+     * `GlobalFieldDataType` and represents the structure of the global field. It defines the expected
+     * properties and their types for the global field.
+     * @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>;
+    /**
+     * 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.
+     * @param {Record<string, unknown>[]} tree - An array of objects representing the tree structure of
+     * the JSON RTE fields.
+     * @param {JsonRTEFieldDataType} fieldStructure - The `fieldStructure` parameter is of type
+     * `JsonRTEFieldDataType` and represents the structure of a JSON RTE field. It contains properties
+     * such as `uid`, `data_type`, and `display_name`.
+     * @param {EntryJsonRTEFieldDataType} field - The `field` parameter is of type
+     * `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>;
+    /**
+     * The function validates the modular blocks field by traversing each module and looking for
+     * references.
+     * @param {Record<string, unknown>[]} tree - The `tree` parameter is an array of objects that
+     * represent the structure of the modular blocks field. Each object in the array represents a level
+     * in the tree structure, and it contains a `field` property that represents the unique identifier of
+     * the modular block at that level.
+     * @param {ModularBlocksDataType} fieldStructure - The `fieldStructure` parameter is of type
+     * `ModularBlocksDataType` and represents the structure of the modular blocks field. It contains
+     * information about the blocks and their properties.
+     * @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>;
+    /**
+     * 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.
+     * @param {GroupFieldDataType} fieldStructure - The `fieldStructure` parameter is of type
+     * `GroupFieldDataType` and represents the structure of the group field. It contains information
+     * about the fields and their types within the group.
+     * @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>;
+    /**
+     * The function `validateReferenceValues` checks if the references in a given field exist in the
+     * provided tree and returns any missing references.
+     * @param {Record<string, unknown>[]} tree - An array of objects representing the tree structure of
+     * the data. Each object in the array represents a node in the tree.
+     * @param {ReferenceFieldDataType} fieldStructure - The `fieldStructure` parameter is of type
+     * `ReferenceFieldDataType` and represents the structure of a reference field. It contains properties
+     * such as `data_type` (the data type of the reference field) and `display_name` (the display name of
+     * the reference field).
+     * @param {EntryReferenceFieldDataType[]} field - The `field` parameter is an array of objects
+     * representing entry reference fields. Each object in the array has properties such as `uid` which
+     * represents the unique identifier of the referenced entry.
+     * @returns The function `validateReferenceValues` returns an array of `EntryRefErrorReturnType`
+     * objects.
+     */
+    validateReferenceValues(tree: Record<string, unknown>[], fieldStructure: ReferenceFieldDataType, field: EntryReferenceFieldDataType[]): EntryRefErrorReturnType[];
+    /**
+     * The function prepares entry metadata by reading and processing files from different locales and
+     * schemas.
+     */
+    prepareEntryMetaData(): Promise<void>;
+}

package/lib/modules/entries.js

@@ -0,0 +1,288 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+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"));
+const path_1 = require("path");
+const fs_1 = require("fs");
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+const messages_1 = require("../messages");
+class Entries {
+    constructor({ log, config, moduleName, ctSchema, gfSchema }) {
+        this.missingRefs = {};
+        this.entryMetaData = [];
+        this.moduleName = 'content-types';
+        this.log = log;
+        this.config = config;
+        this.ctSchema = ctSchema;
+        this.gfSchema = gfSchema;
+        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,
+     * iterates over the schema and looks for references, and returns a list of missing references.
+     * @returns the `missingRefs` object.
+     */
+    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 }));
+        }
+        await this.prepareEntryMetaData();
+        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) {
+                    const entries = (await fsUtility.readChunkFiles.next());
+                    for (const entryUid in entries) {
+                        let entry = 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.log((0, messages_1.$t)(messages_1.auditMsg.SCAN_ENTRY_SUCCESS_MSG, {
+                            title,
+                            local: code,
+                            module: this.config.moduleConfig.entries.name,
+                        }), 'info');
+                    }
+                }
+            }
+        }
+        this.log('', 'info'); // Adding empty line
+        for (let propName in this.missingRefs) {
+            if (!this.missingRefs[propName].length) {
+                delete this.missingRefs[propName];
+            }
+        }
+        return this.missingRefs;
+    }
+    /**
+     * The function `lookForReference` iterates over a given schema and validates different field types
+     * such as reference, global field, JSON, modular blocks, and group fields.
+     * @param {Record<string, unknown>[]} tree - An array of objects representing the tree structure of
+     * the content type or field being validated. Each object in the array has the following properties:
+     * @param {ContentTypeStruct | GlobalFieldDataType | ModularBlockType | GroupFieldDataType}  - -
+     * `tree`: An array of objects representing the tree structure of the content type or field being
+     * validated.
+     * @param {EntryStruct | EntryGlobalFieldDataType | EntryModularBlocksDataType |
+     * 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) {
+                case 'reference':
+                    this.missingRefs[this.currentUid].push(...this.validateReferenceField([...tree, { uid: field.uid, name: field.display_name, field: uid }], field, entry[uid]));
+                    break;
+                case 'global_field':
+                    await this.validateGlobalField([...tree, { uid: field.uid, name: field.display_name, field: uid }], field, entry[uid]);
+                    break;
+                case 'json':
+                    if (field.field_metadata.extension) {
+                        // NOTE Custom field type
+                    }
+                    else if (field.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]);
+                    }
+                    break;
+                case 'blocks':
+                    await this.validateModularBlocksField([...tree, { uid: field.uid, name: field.display_name, field: uid }], field, entry[uid]);
+                    break;
+                case 'group':
+                    await this.validateGroupField([...tree, { uid: field.uid, name: field.display_name, field: uid }], field, entry[uid]);
+                    break;
+            }
+        }
+    }
+    /**
+     * The function `validateReferenceField` validates the reference values of a given field in a tree
+     * structure.
+     * @param {Record<string, unknown>[]} tree - An array of objects representing a tree structure. Each
+     * object in the array should have a unique identifier field.
+     * @param {ReferenceFieldDataType} fieldStructure - The `fieldStructure` parameter is of type
+     * `ReferenceFieldDataType`. It represents the structure of the reference field that needs to be
+     * validated.
+     * @param {EntryReferenceFieldDataType[]} field - The `field` parameter is an array of
+     * `EntryReferenceFieldDataType` objects.
+     * @returns the result of calling the `validateReferenceValues` function with the provided arguments
+     * `tree`, `fieldStructure`, and `field`.
+     */
+    validateReferenceField(tree, fieldStructure, field) {
+        return this.validateReferenceValues(tree, fieldStructure, field);
+    }
+    /**
+     * The function "validateGlobalField" is an asynchronous function that takes in a tree,
+     * fieldStructure, and field as parameters and looks for references in the tree.
+     * @param {Record<string, unknown>[]} tree - The `tree` parameter is an array of objects. Each object
+     * represents a node in a tree structure. The tree structure can be represented as a hierarchical
+     * structure where each object can have child objects.
+     * @param {GlobalFieldDataType} fieldStructure - The `fieldStructure` parameter is of type
+     * `GlobalFieldDataType` and represents the structure of the global field. It defines the expected
+     * properties and their types for the global field.
+     * @param {EntryGlobalFieldDataType} field - The `field` parameter is of type
+     * `EntryGlobalFieldDataType`. It represents a single global field entry.
+     */
+    async validateGlobalField(tree, fieldStructure, field) {
+        // NOTE Any GlobalField related logic can be added here
+        await this.lookForReference(tree, fieldStructure, field);
+    }
+    /**
+     * 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.
+     * @param {Record<string, unknown>[]} tree - An array of objects representing the tree structure of
+     * the JSON RTE fields.
+     * @param {JsonRTEFieldDataType} fieldStructure - The `fieldStructure` parameter is of type
+     * `JsonRTEFieldDataType` and represents the structure of a JSON RTE field. It contains properties
+     * such as `uid`, `data_type`, and `display_name`.
+     * @param {EntryJsonRTEFieldDataType} field - The `field` parameter is of type
+     * `EntryJsonRTEFieldDataType`, which represents a JSON RTE field in an entry. It contains properties
+     * such as `uid`, `attrs`, and `children`.
+     */
+    async validateJsonRTEFields(tree, fieldStructure, field) {
+        var _a;
+        // 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 }],
+                    });
+                }
+            }
+            if (!(0, isEmpty_1.default)(children)) {
+                await this.validateJsonRTEFields(tree, fieldStructure, child);
+            }
+        }
+    }
+    /**
+     * The function validates the modular blocks field by traversing each module and looking for
+     * references.
+     * @param {Record<string, unknown>[]} tree - The `tree` parameter is an array of objects that
+     * represent the structure of the modular blocks field. Each object in the array represents a level
+     * in the tree structure, and it contains a `field` property that represents the unique identifier of
+     * the modular block at that level.
+     * @param {ModularBlocksDataType} fieldStructure - The `fieldStructure` parameter is of type
+     * `ModularBlocksDataType` and represents the structure of the modular blocks field. It contains
+     * information about the blocks and their properties.
+     * @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]);
+            }
+        }
+    }
+    /**
+     * 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.
+     * @param {GroupFieldDataType} fieldStructure - The `fieldStructure` parameter is of type
+     * `GroupFieldDataType` and represents the structure of the group field. It contains information
+     * about the fields and their types within the group.
+     * @param {EntryGroupFieldDataType} field - The `field` parameter is of type
+     * `EntryGroupFieldDataType` and represents a single group field entry.
+     */
+    async 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);
+    }
+    /**
+     * The function `validateReferenceValues` checks if the references in a given field exist in the
+     * provided tree and returns any missing references.
+     * @param {Record<string, unknown>[]} tree - An array of objects representing the tree structure of
+     * the data. Each object in the array represents a node in the tree.
+     * @param {ReferenceFieldDataType} fieldStructure - The `fieldStructure` parameter is of type
+     * `ReferenceFieldDataType` and represents the structure of a reference field. It contains properties
+     * such as `data_type` (the data type of the reference field) and `display_name` (the display name of
+     * the reference field).
+     * @param {EntryReferenceFieldDataType[]} field - The `field` parameter is an array of objects
+     * representing entry reference fields. Each object in the array has properties such as `uid` which
+     * represents the unique identifier of the referenced entry.
+     * @returns The function `validateReferenceValues` returns an array of `EntryRefErrorReturnType`
+     * objects.
+     */
+    validateReferenceValues(tree, fieldStructure, field) {
+        const missingRefs = [];
+        const { data_type, display_name } = fieldStructure;
+        for (const reference of field !== null && field !== void 0 ? field : []) {
+            const { uid } = reference;
+            // 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.entryMetaData, { uid });
+            if (!refExist) {
+                missingRefs.push(reference);
+            }
+        }
+        return missingRefs.length
+            ? [
+                {
+                    tree,
+                    data_type,
+                    missingRefs,
+                    display_name,
+                    uid: this.currentUid,
+                    name: this.currentTitle,
+                    treeStr: tree
+                        .map(({ name }) => name)
+                        .filter((val) => val)
+                        .join(' ➜ '),
+                },
+            ]
+            : [];
+    }
+    /**
+     * The function prepares entry metadata by reading and processing files from different locales and
+     * schemas.
+     */
+    async prepareEntryMetaData() {
+        this.log(messages_1.auditMsg.PREPARING_ENTRY_METADATA, 'info');
+        const localesFolderPath = (0, path_1.resolve)(this.config.basePath, this.config.moduleConfig.locales.dirName);
+        const localesPath = (0, path_1.join)(localesFolderPath, this.config.moduleConfig.locales.fileName);
+        const masterLocalesPath = (0, path_1.join)(localesFolderPath, 'master-locale.json');
+        this.locales = (0, 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'))));
+        for (const { code } of this.locales) {
+            for (const { uid } of this.ctSchema) {
+                let basePath = (0, path_1.join)(this.folderPath, uid, code);
+                let fsUtility = new cli_utilities_1.FsUtility({ basePath, indexFileName: 'index.json' });
+                let indexer = fsUtility.indexFileContent;
+                for (const _ in indexer) {
+                    const entries = (await fsUtility.readChunkFiles.next());
+                    for (const entryUid in entries) {
+                        let { title } = entries[entryUid];
+                        this.entryMetaData.push({ uid: entryUid, title });
+                    }
+                }
+            }
+        }
+    }
+}
+exports.default = Entries;

package/lib/modules/global-fields.d.ts

@@ -0,0 +1,27 @@
+import ContentType from './content-types';
+import { GroupFieldDataType, ModularBlocksDataType } from '../types';
+export default class GlobalField extends ContentType {
+    /**
+     * The above function is an asynchronous function that runs a validation and returns any missing
+     * references.
+     * @returns the value of the variable `missingRefs`.
+     */
+    run(): Promise<Record<string, any>>;
+    /**
+     * The function validates a field containing modular blocks by traversing each block and checking for
+     * references in a given tree.
+     * @param {Record<string, unknown>[]} tree - The `tree` parameter is an array of objects that
+     * represents a tree structure. Each object in the array represents a node in the tree.
+     * @param {ModularBlocksDataType} field - The `field` parameter is of type `ModularBlocksDataType`.
+     */
+    validateModularBlocksField(tree: Record<string, unknown>[], field: ModularBlocksDataType): Promise<void>;
+    /**
+     * The function "validateGroupField" performs group field validation by looking for a reference in a
+     * tree structure.
+     * @param {Record<string, unknown>[]} tree - The `tree` parameter is an array of objects representing
+     * a tree structure. Each object in the array represents a node in the tree and has properties like
+     * `uid` and `name`.
+     * @param {GroupFieldDataType} field - The `field` parameter is of type `GroupFieldDataType`.
+     */
+    validateGroupField(tree: Record<string, unknown>[], field: GroupFieldDataType): Promise<void>;
+}