Hi, how can we help?

Directory Structure

This document explores the directory structure of a ZDK CLI project directory, detailing its component directories and files and their functionalities.

{ZDK-Project-Name} Project directory

The directory structure of ZDK CLI consists of a project directory named {ZDK-Project-Name}, which includes two main directories: .zdk and crm.

The {ZDK-Project-Name} is the project name given during the zdk init command. The crm directory comprises the meta directory, which has modules, profiles, roles, and widgets directories. Each module directory has corresponding directories of fields, layouts and other related metadata directories. The .zdk directory consists of .logs, .org, and .store directories that are essential for the proper functioning of the ZDK CLI.

{ZDK-Project-Name}/crm directory

The crm directory is the parent directory containing files of the entire metadata of the CRM, and the data inside the same will be used for metadata-related operations. It consists of two sections: meta section and data section. The meta section consists of the meta directory. The data section consists of details of widgets with internal hosting. In future releases, when functions, client scripts etc are supported, their corresponding folders will also be created here.

{ZDK-Project-Name}/crm/meta directory

The meta directory consists of metadata resources' folders (modules, profiles, roles, and widgets). In future releases, when other metadata resources  such as related list, custom view, etc are supported, their corresponding folders will also be created.

Inside these directories, each metadata resource is represented with its own distinct file name. To ensure its uniqueness, the file name is constructed from the API name of the meta resource. For example, fields and profiles will be as below:

• Fields : {field_api_name}.fields-meta.json
• Profiles : {profile_api_name}.profiles-meta.json 

For instance, in the leads module, the fields "First Name" and "Last Name" will be denoted by the file names First_Name.fields-meta.json and Last_Name.fields-meta.json, respectively. They will present inside this folder structure: crm/meta/modules/Leads/fields. For details regarding name and location of JSON files of different metadata types, refer this table.

{ZDK-Project-Name}/meta.json file

The meta.json file contains the json structure specifying the set of metadata to pull from your CRM org during the zdk org:pull command. You can pull all metadata that are accessible to your profile or specific metadata from your CRM org based on your requirement. By default, the file is configured to pull all metadata.

Structure of the meta.json file

        {
          "resource_type": "all|specific",
          "resources": [
            {
              "resource_type": "modules|fields|layouts|profiles|roles|widgets",
              "resources": [
                {
                  "api_name": "{specific_api_name}"
                }
              ]
            }
          ]
        } 
        

• resource_type :string, mandatory. This field denotes the scope of data/metadata retrieval. It indicates whether all resources or specific resources should be retrieved. Possible values : all, specific. If the value is specific, within each nested resources object, it further specifies the details about a specific type of resource.
• resources :json array, mandatory when resource_type is specific. This property contains the details of specific metadata in an array of objects. Each array element consists of a nested child resource_type string and child resources json array.
  • resource_type :string, mandatory when resource_type is specific. It indicates the specific type of resource that should be pulled. Possible values: modules, fields, widgets, profiles, roles, layouts.
  • resources :json array, mandatory when resource_type is specific. This json array represents an array of API names of a specific resource.
    • api_name :string This consists of the API name of the specific resources. The wildcard (*) can be used with this key. It represents all values. For module specific resources like layouts and fields, to pull all fields of a module or to pull all layouts of module you can use api_name like {module_api_name}.* for eg: Leads.*

The meta.json in the below example can be used to pull all metadata.

        {
           "resource_type": "all"
        }
        

The meta.json in the below example can be used to pull specific metadata.

        {
          "resource_type": "specific",
          "resources": [
            {
              "resource_type": "profiles",
              "resources": [
                {
                  "api_name": "*"
                }
              ]
            },
            {
              "resource_type": "roles",
              "resources": [
                {
                  "api_name": "*"
                }
              ]
            },
            {
              "resource_type": "modules",
              "resources": [
                {
                  "api_name": "Accounts"
                }
              ]
            },
            {
              "resource_type": "fields",
              "resources": [
                {
                  "api_name": "Accounts.Account_Name"
                }
              ]
            },
            {
              "resource_type": "layouts",
              "resources": [
                {
                  "api_name": "Accounts.*"
                }
              ]
            },
            {
              "resource_type": "widgets",
              "resources": [
                {
                  "api_name": "Maps"
                }
              ]
            }
          ]
        }
                            

The image below shows the resultant ZDK project directory structure on using the above sample meta.json.

{ZDK-Project-Name}/zdk-project.json file

This file contains information about the zdk project.

        {
          "meta_directory": [
            {
              "path": "crm",
              "default": true
            }
          ],
          "name": "ZDKProject",
          "accounts_url": "https://accounts.zoho.com",
          "domain_url": "https://www.zohoapis.com",
          "api_version": "6"
        }

• meta_directory: The 'meta_directory' has information about the default metadata directory which should be considered while running zdk commands in this project. 
• name: The project directory is identified by the 'name' field.
• api_version: The 'api_version' property represents the ZDK files version, facilitating structural modifications across different versions. Like API versions, ZDK also follows its own request and response body standards. This version helps to differentiate the JSON given inside the ZDK Files. 
• accounts_url: The 'accounts_url' property represents the appropriate domain URL for accounts to facilitate authentication requests to Zoho CRM.
• domain_url: The 'domain_url' should be proper sandbox domain URL to make an API Call to Zoho CRM, which will be set automatically after the execution of the zdk auth:login command.

{ZDK-Project-Name}/.zdkignore file

This file contains path of the file or directory which needed to be ignored during the execution of these ZDK commands: zdk org:push, zdk:org:push:result, and zdk org:status

The entries consist of file paths followed by file names, with support for regex to facilitate the inclusion of entries. Please refer to the example below where the entries are for Manager role.

                        crm/meta/roles/Manager.roles-meta.json
        

{ZDK-Project-Name}/.zdk directory

The .zdk directory consists of .logs, .org, and .store directories. These directories are essential for the proper functioning of the ZDK CLI and should not be modified by the user. Any modification in this directories can lead to corruption in the ZDK Project.

{ZDK-Project-Name}/.zdk/.logs directory

The .logs directory contains of log files and a meta file for the log files.

{ZDK-Project-Name}/.zdk/.logs /.*audit.json file

This file is the meta file for other log files. It contains the auto-generated logs.

{ZDK-Project-Name}/.zdk/.logs/ZDK-CLI-{year-month-date}.log file

This file comprises log information. The format adhered to is as follows: "log level [time (milliseconds)]: message".

A new log file, formatted as "ZDK-CLI-{year-month-date}.log", is generated daily. Each log file spans a duration of seven days, after which it is automatically deleted. Please note that the maximum size allotted for a logger file is 20 MB. If a single log file surpasses this size, a new log file will be initiated, appended with a distinctive suffix value.