@pega/sdk 0.0.1

package/templates/react-sdk-reference/src/components/template/ListView/utils.ts

@@ -0,0 +1,781 @@
+import getDefaultViewMeta from './DefaultViewMeta';
+
+const USER_REFERENCE = 'UserReference';
+const PAGE = '!P!';
+const PAGELIST = '!PL!';
+
+export const formatConstants = {
+  WorkStatus: 'WorkStatus',
+  Integer: 'Integer',
+  WorkLink: 'WorkLink'
+};
+
+class DataApi {
+  mappedPropertyToOriginalProperty: any;
+  originalPropertyToMappedProperty: any;
+  showRecords: any;
+  constructor(showRecords = true) {
+    this.showRecords = showRecords;
+    this.originalPropertyToMappedProperty = {};
+    this.mappedPropertyToOriginalProperty = {};
+    this.setShowRecords = this.setShowRecords.bind(this);
+    this.setPropertyMaps = this.setPropertyMaps.bind(this);
+    this.getMappedProperty = this.getMappedProperty.bind(this);
+    this.getOriginalProperty = this.getOriginalProperty.bind(this);
+  }
+
+  setShowRecords(showRecords) {
+    this.showRecords = showRecords;
+  }
+
+  setPropertyMaps(originalToMappedPropertyObj = {}, mappedToOriginalPropertyObj = {}) {
+    this.originalPropertyToMappedProperty = {
+      ...this.originalPropertyToMappedProperty,
+      ...originalToMappedPropertyObj
+    };
+    this.mappedPropertyToOriginalProperty = {
+      ...this.mappedPropertyToOriginalProperty,
+      ...mappedToOriginalPropertyObj
+    };
+  }
+
+  getMappedProperty(propertyName) {
+    return this.originalPropertyToMappedProperty[propertyName] ?? propertyName;
+  }
+
+  getOriginalProperty(propertyName) {
+    return this.mappedPropertyToOriginalProperty[propertyName] ?? propertyName;
+  }
+}
+
+export async function getContext(componentConfig) {
+  const {
+    promisesArray = [] // array of promises which can be invoked paralelly,
+  } = componentConfig;
+  const promisesResponseArray = await Promise.all(promisesArray);
+  const dataApi = new DataApi();
+  return {
+    promisesResponseArray,
+    setPropertyMaps: dataApi.setPropertyMaps,
+    getMappedProperty: dataApi.getMappedProperty,
+    getOriginalProperty: dataApi.getOriginalProperty
+  };
+}
+
+/**
+ * [getFieldNameFromEmbeddedFieldName]
+ * Description    -               converting embeddedField name starting with !P! or !PL! to normal field
+ * @ignore
+ * @param {string} propertyName   EmbeddedField name starting with !P! or !PL!
+ * @returns {string}              returns converted string without !P! or !PL! and :
+ *
+ * @example <caption>Example for getFieldNameFromEmbeddedFieldName </caption>
+ * getFieldNameFromEmbeddedFieldName('!P!Organisation:Name') return 'Organisation.Name'
+ * getFieldNameFromEmbeddedFieldName('!PL!Employees:Name') return 'Employees.Name'
+ */
+export function getFieldNameFromEmbeddedFieldName(propertyName) {
+  let value = propertyName;
+  if (value.startsWith(PAGE) || value.startsWith(PAGELIST)) {
+    value = value.substring(value.lastIndexOf('!') + 1);
+    value = value.replace(/:/g, '.');
+  }
+  return value;
+}
+
+/**
+ * [updateMetaEmbeddedFieldID]
+ * Description    -           If the fieldID in meta starts with '!P!' or '!PL!' and contains ':' then replace them with .(dot)
+ * @ignore
+ * @param {Array} metaFields  Fields metadata Array. Contains metadata of all the fields.
+ */
+export function updateMetaEmbeddedFieldID(metaFields) {
+  return metaFields.forEach(metaField => {
+    if (metaField.fieldID?.startsWith(PAGE) || metaField.fieldID?.startsWith(PAGELIST)) {
+      metaField.fieldID = getFieldNameFromEmbeddedFieldName(metaField.fieldID);
+    }
+  });
+}
+
+export const isEmbeddedField = field => {
+  if (field?.startsWith('@')) {
+    field = field.substring(field.indexOf(' ') + 1);
+    if (field[0] === '.') field = field.substring(1);
+  }
+  return field?.indexOf('.') > 0;
+};
+
+/**
+ * [isPageListProperty]
+ * Description    -        checking if propertyName is pageList or not
+ * @ignore
+ * @param {string} propertyName   PropertyName
+ * @returns {boolean}  true if property is pageList else false
+ *
+ * @example <caption>Example for isPageListProperty </caption>
+ * isPageListProperty('!PL!Employees.Name') return true
+ * isPageListProperty('!P!Employees.Name') return false
+ * isPageListProperty('Name') return false
+ */
+export function isPageListProperty(propertyName) {
+  return propertyName.startsWith(PAGELIST);
+}
+
+export const isPageListInPath = (propertyName, currentClassID) => {
+  if (!propertyName.includes('.')) {
+    return false;
+  }
+  const [first, ...rest] = propertyName.split('.');
+  const metadata: any = PCore.getMetadataUtils().getPropertyMetadata(first, currentClassID);
+  if (metadata?.type === 'Page List') {
+    return true;
+  }
+  return isPageListInPath(rest.join('.'), metadata?.pageClass);
+};
+
+/**
+ * [getEmbeddedFieldName]
+ * Description    -               converting normal field name to embedded field starting with !P! or !PL!
+ * @ignore
+ * @param {string} propertyName   Field name
+ * @param {string} classID        classID of datapage
+ * @returns {string}              returns converted string with !P! or !PL! and :
+ *
+ * @example <caption>Example for getEmbeddedFieldName </caption>
+ * For page property, getEmbeddedFieldName('Organisation.Name') return '!P!Organisation:Name'
+ * For pageList property, getEmbeddedFieldName('Employees.Name') return '!PL!Employees:Name'
+ */
+
+export function getEmbeddedFieldName(propertyName, classID) {
+  let value = propertyName;
+  if (isPageListInPath(value, classID)) {
+    value = `!PL!${value.replace(/\./g, ':')}`;
+  } else {
+    value = `!P!${value.replace(/\./g, ':')}`;
+  }
+  return value;
+}
+
+/**
+ * [preparePropertyMaps]
+ * Description    -        preparing maps for property names and set it in dataApi context
+ * @ignore
+ * @param {Array} fields   fields array
+ * @param {string} classID  classID of datapage
+ * @param {string} context  dataApi context
+ * @returns {boolean} true if pageListProperty is present
+ */
+export function preparePropertyMaps(fields, classID, context) {
+  const { setPropertyMaps } = context;
+  const maps = fields.reduce(
+    (acc, field) => {
+      let { value } = field.config;
+      if (value.startsWith('@')) {
+        value = value.substring(value.indexOf(' ') + 1);
+        if (value[0] === '.') value = value.substring(1);
+      }
+      let name = value;
+      // Preparing name for embedded property
+      if (isEmbeddedField(name)) {
+        name = getEmbeddedFieldName(name, classID);
+      }
+      if (isPageListProperty(name) && !acc[2]) {
+        acc[2] = true;
+      }
+      acc[0][value] = name;
+      acc[1][name] = value;
+
+      return acc;
+    },
+    [{}, {}, false]
+  );
+  setPropertyMaps(maps[0], maps[1]);
+  return maps[2];
+}
+
+/**
+ * [getConfigEmbeddedFieldsMeta]
+ * Description    -           Get the metadata for configured embedded fields
+ * @ignore
+ * @param {Set} configFields  Set of config fields
+ * @param {string} classID    clasID of datapage
+ * @returns {Array}           Metadata of configured embedded fields
+ */
+export function getConfigEmbeddedFieldsMeta(configFields, classID) {
+  const configEmbeddedFieldsMeta: any[] = [];
+  configFields.forEach(field => {
+    let value = field;
+    if (isEmbeddedField(value)) {
+      // conversion Page.PageList[].property => Page.PageList.property
+      if (value.includes('[')) {
+        value = value.substring(0, value.indexOf('[')) + value.substring(value.indexOf(']') + 1);
+      }
+      const meta: any = PCore.getMetadataUtils().getEmbeddedPropertyMetadata(value, classID);
+      meta.fieldID = field;
+      configEmbeddedFieldsMeta.push(meta);
+    }
+  });
+  return configEmbeddedFieldsMeta;
+}
+
+/**
+ * [mergeConfigEmbeddedFieldsMeta]
+ * Description    -           Get the metadata for configured embedded fields
+ * @ignore
+ * @param {Array} configEmbeddedFieldsMeta  config fields metadata.
+ * @param {Array} metaFields  Fields metadata Array. Contains metadata of all the fields
+ */
+export function mergeConfigEmbeddedFieldsMeta(configEmbeddedFieldsMeta, metaFields) {
+  const mergedMetaFields = [...metaFields];
+  configEmbeddedFieldsMeta.forEach(configFieldMeta => {
+    const fieldMeta = metaFields.find(metaField => metaField.fieldID === configFieldMeta.fieldID);
+    if (!fieldMeta) mergedMetaFields.push(configFieldMeta);
+  });
+  return mergedMetaFields;
+}
+
+const oldToNewFieldTypeMapping = {
+  'Date Time': 'Date & time',
+  Date: 'Date only'
+};
+
+/**
+ * [updateFieldType]
+ * Description    -           Updates the field type if its changed in the new implementation. Such mapping is maintained in oldToNewFieldTypeMapping.
+ * @ignore
+ * @param {Array} metaFields  Fields metadata Array. Contains metadata of all the fields.
+ */
+function updateFieldType(metaFields) {
+  metaFields.forEach(metaField => {
+    if (metaField.type) metaField.type = oldToNewFieldTypeMapping[metaField.type] || metaField.type;
+  });
+}
+
+function getPresetMetaAttribute(attribute) {
+  const {
+    type,
+    config: { label, value }
+  } = attribute;
+  return {
+    type,
+    name: value.startsWith('@') ? value.substring(4) : value,
+    label: label.startsWith('@') ? label.substring(3) : label
+  };
+}
+
+/**
+ * [generateViewMetaData]
+ * Description - Returns a list of  metaobjects of the fields provided.
+ * @ignore
+ * @param   {Array}   rawFields         List of fields to update meta for
+ * @param   {string}  classID          Class ID from the response
+ * @returns {Array}                    List of fields with updated meta objects.
+ */
+function generateViewMetaData(rawFields, classID, showField) {
+  return rawFields.map(item => getDefaultViewMeta(item, classID, showField));
+}
+
+/**
+ * [getConfigFields]
+ * Description - Returns list of config fields with primary fields meta updated.
+ * @ignore
+ * @param   {Array}   configFields      List of Authored fields
+ * @param   {Array}   primaryFields     List of Primary Fields
+ * @param   {Array}   metaFields        Metadata of all fields
+ * @param   {string}  classID           Class ID from the response
+ * @returns {Array}                     List of all fields with their meta updated.
+ */
+function getConfigFields(configFields, primaryFields, metaFields, classID) {
+  const presetConfigFields = configFields;
+  const primaryFieldsViewIndex = presetConfigFields.findIndex(field => field.config.value === 'pyPrimaryFields');
+  if (!primaryFields || !primaryFields.length) {
+    if (primaryFieldsViewIndex < 0) return presetConfigFields;
+
+    presetConfigFields.splice(primaryFieldsViewIndex, 1);
+
+    return presetConfigFields;
+  }
+
+  if (primaryFieldsViewIndex > -1) {
+    // list of uncommon fields - non overlap of primary fields grouped view and independent entity columns of primary type
+    const uncommonFieldsList = primaryFields.filter(
+      primaryField => !presetConfigFields.some(presetConfigField => presetConfigField.config.value.split('.')[1] === primaryField)
+    );
+    const uncommonFieldsRawMeta: any[] = [];
+    uncommonFieldsList.forEach(uncommonField => {
+      const uncommonFieldMeta = metaFields.find(metaField => metaField.fieldID === uncommonField);
+      if (uncommonFieldMeta) uncommonFieldsRawMeta.push(uncommonFieldMeta);
+    });
+    const uncommonFieldsConfigMeta = generateViewMetaData(uncommonFieldsRawMeta, classID, true);
+
+    presetConfigFields.splice(primaryFieldsViewIndex, 1, ...uncommonFieldsConfigMeta);
+  }
+  return presetConfigFields;
+}
+
+/**
+ * [getTableConfigFromPresetMeta]
+ * Description - Get the table config from the presets meta.
+ * @ignore
+ * @param   {object}    presetMeta          Presets meta
+ * @param   {boolean}   isMetaWithPresets   true if meta has presets else false
+ * @param   {Function}  getPConnect         Callback to get the PConnect object
+ * @param   {string}    classID             Class ID from the response
+ * @param   {Array}     primaryFields       List of Primary Fields
+ * @param   {Array}     metaFields          List of all metafields
+ * @returns {object}                        Table config object
+ */
+export function getTableConfigFromPresetMeta(presetMeta, isMetaWithPresets, getPConnect, classID, primaryFields, metaFields) {
+  let presetId;
+  let presetName;
+  let cardHeader;
+  let secondaryText;
+  let timelineDate;
+  let timelineTitle;
+  let timelineStatus;
+  let timelineIcon;
+  let { filterExpression } = getPConnect().getRawMetadata().config;
+  let fieldsMeta;
+  let configFields;
+  if (isMetaWithPresets) {
+    presetId = presetMeta.id;
+    presetName = presetMeta.label;
+    cardHeader = presetMeta.cardHeader && getPresetMetaAttribute(presetMeta.cardHeader);
+    secondaryText = presetMeta.secondaryText && getPresetMetaAttribute(presetMeta.secondaryText);
+    timelineDate = presetMeta.timelineDate && getPresetMetaAttribute(presetMeta.timelineDate);
+    timelineTitle = presetMeta.timelineTitle && getPresetMetaAttribute(presetMeta.timelineTitle);
+    timelineStatus = presetMeta.timelineStatus && getPresetMetaAttribute(presetMeta.timelineStatus);
+    timelineIcon = presetMeta.timelineIcon && getPresetMetaAttribute(presetMeta.timelineIcon);
+    filterExpression = presetMeta.config.filterExpression;
+    [fieldsMeta] = presetMeta.children;
+    if (
+      presetMeta.timelineTitle &&
+      !fieldsMeta.children.find(fieldMeta => {
+        return fieldMeta?.config?.value === presetMeta.timelineTitle?.config?.value;
+      })
+    ) {
+      const { type, config } = presetMeta.timelineTitle;
+      fieldsMeta.children.push({ type, config: { ...config, show: false } });
+    }
+    if (
+      presetMeta.timelineDate &&
+      !fieldsMeta.children.find(fieldMeta => {
+        return fieldMeta?.config?.value === presetMeta.timelineDate?.config?.value;
+      })
+    ) {
+      const { type, config } = presetMeta.timelineDate;
+      fieldsMeta.children.push({ type, config: { ...config, show: false } });
+    }
+    configFields = getConfigFields(fieldsMeta.children, primaryFields, metaFields, classID);
+  } else {
+    fieldsMeta = presetMeta.props;
+    configFields = getConfigFields(
+      fieldsMeta
+        .getPConnect()
+        .getChildren()
+        ?.map(child => {
+          return child.getPConnect().getRawMetadata();
+        }),
+      primaryFields,
+      metaFields,
+      classID
+    );
+  }
+  return {
+    presetId,
+    presetName,
+    cardHeader,
+    secondaryText,
+    timelineDate,
+    timelineTitle,
+    timelineStatus,
+    timelineIcon,
+    filterExpression,
+    fieldsMeta,
+    configFields
+  };
+}
+
+/**
+ * [getReportColumns]
+ * Description - Returns a set of columns from the report response.
+ * @ignore
+ * @param   {object} response -
+ * @returns {Set} Set of columns from the report response
+ */
+function getReportColumns(response) {
+  const {
+    data: { data: reportColumns }
+  } = response;
+  const reportColumnsSet = new Set();
+  reportColumns?.forEach(item => {
+    let val = item.pyFieldName;
+    // Remove '.' from index 0 only, if '.' is present
+    if (val[0] === '.') {
+      val = val.substring(1);
+    }
+    reportColumnsSet.add(val);
+  });
+  return reportColumnsSet;
+}
+
+/**
+ * [getConfigFieldValue]
+ * Descritpion - Returns a valid value for a configuration field. Remove any annotations and also "."
+ * @ignore
+ * @param   {object} config
+ *                   config.value - Raw value
+ * @returns {string} value - Value with out any annotations or "."
+ */
+function getConfigFieldValue(config) {
+  let { value } = config;
+  if (value.startsWith('@')) {
+    value = value.substring(value.indexOf(' ') + 1);
+    if (value[0] === '.') value = value.substring(1);
+  }
+  return value;
+}
+
+/**
+ * [prepareConfigFields]
+ * Description - Prepares a set of configuration fields and pushes each config type to a set using the callback parameter.
+ * @ignore
+ * @param   {object}    configFields          List of Authored fields
+ * @param   {Function}  pushToComponentsList Callback to push the field type to a set.
+ * @returns {Set}       configFieldSet
+ */
+function prepareConfigFields(configFields, pushToComponentsList) {
+  const configFieldSet = new Set();
+  configFields.forEach(item => {
+    pushToComponentsList(item.type);
+    const val = getConfigFieldValue(item.config);
+    configFieldSet.add(val);
+  });
+  return configFieldSet;
+}
+
+/**
+ * [findAuthoredField]
+ * Description - Finds an authored field from yhe list of config fields.
+ * @ignore
+ * @param   {Array}   configFields List of Authored fields
+ * @param   {string}  fieldID      Filter
+ * @returns {object}              config with its field value equal to fieldID, which means an authored field
+ */
+function findAuthoredField(configFields, fieldID) {
+  return configFields.find(configField => {
+    const val = getConfigFieldValue(configField.config);
+    return val === fieldID;
+  });
+}
+
+/**
+ * [findAndUpdateAuthoredFieldConfig]
+ * Description - Find the authored field, and update its config.
+ * @ignore
+ * @param   {Array}   configFields List of Authored fields
+ * @param   {object}  item        Field item to copy displayAs and category information
+ * @param   {string}  classId     classID from the response
+ */
+function findAndUpdateAuthoredFieldConfig(configFields, item, classId) {
+  const authoredField = findAuthoredField(configFields, item.fieldID);
+  if (authoredField?.config) {
+    if (item.displayAs) {
+      authoredField.config.displayAs = item.displayAs;
+    }
+    authoredField.config.classID = item.classID ?? classId;
+
+    if (authoredField.type === USER_REFERENCE) {
+      authoredField.config.associationID = item.associationID || item.fieldID;
+    }
+    authoredField.config.category = item.category;
+    // FieldType identifies whether the field is configured as pickList
+    authoredField.config.fieldType = item.fieldType;
+    // type defined on the property rule,
+    // used for the picklist field to assign the appropriate type
+    authoredField.config.propertyType = item.dataType || item.type;
+  }
+}
+
+/**
+ * [isAnExtraField]
+ * Description - Returns true if the field is an extra field. Extra field is the one which is not authored but part of the report.
+ * @ignore
+ * @param   {Array}   configFields      List of Authored fields
+ * @param   {Set}     configFieldSet    Set if Authored filed values
+ * @param   {Set}     reportColumnsSet Set of columns from the report
+ * @param   {object}  item             Config field item
+ * @param   {string}  classId          Class ID from the response
+ * @param   {boolean} showDynamicFields Flag indicating whether fields are fetched dynamically at runtime
+ * @returns {boolean}                  true If the field is an extra field else false.
+ */
+function isAnExtraField(configFields, configFieldSet, reportColumnsSet, item, classId, showDynamicFields) {
+  // Is the field already present in authoring metadata?
+  // Mutates config fields to copy displayAs and category information
+  if (configFieldSet.has(item.fieldID)) {
+    findAndUpdateAuthoredFieldConfig(configFields, item, classId);
+    return false;
+  }
+
+  // If field is not authored and not part of report columns then discard it
+  return showDynamicFields || !!reportColumnsSet.has(item.fieldID);
+}
+
+/**
+ * [prepareExtraFields]
+ * Description - Returns a list of extra fields with their meta updated.
+ * @ignore
+ * @param   {Array}   metaFields       List of fields
+ * @param   {Array}   configFields      List of Authored fields
+ * @param   {Set}     configFieldSet    Set if Authored filed values
+ * @param   {Set}     reportColumnsSet Set of columns from the report
+ * @param   {string}  classID          Class ID from the response
+ * @param   {boolean} showDynamicFields Flag indicating whether fields are fetched dynamically at runtime
+ * @returns {Array}                    List of extra fields with their meta updated.
+ */
+function prepareExtraFields(metaFields, configFields, configFieldSet, reportColumnsSet, classID, showDynamicFields) {
+  // Filter all the extra fields
+  const extraFileds = metaFields.filter(item => {
+    return isAnExtraField(configFields, configFieldSet, reportColumnsSet, item, classID, showDynamicFields);
+  });
+  return generateViewMetaData(extraFileds, classID, false);
+  // Update the meta object of each of the extra fields.
+}
+
+const AssignDashObjects = ['Assign-Worklist', 'Assign-WorkBasket'];
+
+function isFLProperty(label) {
+  return label?.startsWith('@FL');
+}
+
+function getFieldLabel(fieldConfig) {
+  const { label, classID, caption } = fieldConfig;
+  let fieldLabel = (label ?? caption)?.substring(4);
+  const labelSplit = fieldLabel?.split('.');
+  const propertyName = labelSplit?.pop();
+  const fieldMetaData: any = PCore.getMetadataUtils().getPropertyMetadata(propertyName, classID) ?? {};
+  fieldLabel = fieldMetaData.label ?? fieldMetaData.caption ?? propertyName;
+
+  const definedOnClassID = fieldMetaData.definedOnClassID;
+  const localeValue = PCore.getLocaleUtils().getLocaleValue(
+    fieldLabel,
+    `${definedOnClassID ?? fieldMetaData.classID ?? classID}.${propertyName}`,
+    PCore.getLocaleUtils().FIELD_LABELS_BUNDLE_KEY,
+    null
+  );
+  return localeValue || fieldLabel;
+}
+
+function populateRenderingOptions(name, config, field) {
+  const shouldDisplayAsSemanticLink = 'displayAsLink' in field.config && field.config.displayAsLink;
+  if (shouldDisplayAsSemanticLink) {
+    config.customObject.isAssignmentLink = AssignDashObjects.includes(field.config.classID);
+    if (field.config.value.startsWith('@CA')) {
+      config.customObject.isAssociation = true;
+    }
+    config.cellRenderer = formatConstants.WorkLink;
+  } else if (name === 'pyStatusWork' || name === 'pyAssignmentStatus') {
+    config.cellRenderer = formatConstants.WorkStatus;
+  } else if (name === 'pxUrgencyWork') {
+    config.cellRenderer = formatConstants.Integer;
+  }
+}
+
+export function initializeColumns(fields: any[] = [], getMappedProperty: any = null) {
+  return fields.map((field, originalColIndex) => {
+    let name = field.config.value;
+
+    if (name.startsWith('@')) {
+      name = name.substring(name.indexOf(' ') + 1);
+      if (name[0] === '.') name = name.substring(1);
+    }
+    name = getMappedProperty?.(name) ?? name;
+
+    let label = field.config.label || field.config.caption;
+    const { show = true, displayAs } = field.config;
+    if (isFLProperty(label)) {
+      label = getFieldLabel(field.config);
+    } else if (label.startsWith('@')) {
+      label = label.substring(3);
+    }
+
+    const config = {
+      name,
+      label,
+      show,
+      classID: field.config.classID,
+      id: field.id || name || originalColIndex,
+      displayAs,
+      associationID: field.config.associationID,
+      ...(field.config.classID && { category: field.config.category }),
+      customObject: {},
+      fieldType: field.config.fieldType,
+      meta: {
+        ...field
+      }
+    };
+
+    populateRenderingOptions(name, config, field);
+
+    return config;
+  });
+}
+
+export const getItemKey = fields => {
+  let itemKey;
+  if (fields.findIndex(field => field.id === 'pyGUID') > -1) {
+    itemKey = 'pyGUID';
+  } else {
+    itemKey = 'pzInsKey';
+  }
+  return itemKey;
+};
+
+export function preparePatchQueryFields(fields, isDataObject = false, classID = '') {
+  const queryFields: any[] = [];
+  fields.forEach(field => {
+    const patchFields: any[] = [];
+    if (field.cellRenderer === 'WorkLink') {
+      if (field.customObject && field.customObject.isAssignmentLink) {
+        const associationName = field.name.includes(':') ? `${field.name.split(':')[0]}:` : '';
+        patchFields.push(`${associationName}pzInsKey`);
+        patchFields.push(`${associationName}pxRefObjectClass`);
+      } else if (field.customObject && field.customObject.isAssociation) {
+        const associationCategory = field.name.split(':')[0];
+        patchFields.push(`${associationCategory}:pyID`);
+        patchFields.push(`${associationCategory}:pzInsKey`);
+        patchFields.push(`${associationCategory}:pxObjClass`);
+      } else if (isDataObject) {
+        const dataViewName = PCore.getDataTypeUtils().getSavableDataPage(classID);
+        const dataPageKeys = PCore.getDataTypeUtils().getDataPageKeys(dataViewName);
+        dataPageKeys?.forEach(item => (item.isAlternateKeyStorage ? patchFields.push(item.linkedField) : patchFields.push(item.keyName)));
+      } else {
+        patchFields.push('pyID');
+        patchFields.push('pzInsKey');
+        patchFields.push('pxObjClass');
+      }
+    }
+    patchFields.forEach(k => {
+      if (!queryFields.find(q => q === k)) {
+        queryFields.push(k);
+      }
+    });
+  });
+
+  return queryFields;
+}
+
+/**
+ * Update the renderer type for the properties of type Page.
+ */
+export function updatePageFieldsConfig(configFields, parentClassID) {
+  return configFields.forEach(item => {
+    const {
+      type,
+      config: { value }
+    } = item;
+    const propertyName = PCore.getAnnotationUtils().getPropertyName(value);
+    if (isEmbeddedField(value) && !isPageListInPath(propertyName, parentClassID)) {
+      item.config.componentType = type;
+      item.type = 'PagePropertyRenderer';
+    }
+  });
+}
+
+export const readContextResponse = async (context, params) => {
+  const { getPConnect, apiContext, setListContext, children, showDynamicFields, referenceList, isDataObject, ref } = params;
+  const { promisesResponseArray, setShowRecords, apiContext: otherContext } = context;
+
+  const listOfComponents: any[] = [];
+  ref.setShowRecords = setShowRecords;
+  const {
+    data: { fields: metaFields, classID, isQueryable }
+  } = promisesResponseArray[0];
+  let {
+    data: { primaryFields }
+  } = promisesResponseArray[0];
+  // When list is configured with Include all class fields configuration, provide support for Primary fields column
+  if (showDynamicFields) {
+    const sourceMetadata: any = PCore.getMetadataUtils().getDataPageMetadata(referenceList);
+    if (sourceMetadata?.primaryFields) {
+      primaryFields = sourceMetadata.primaryFields;
+    }
+    // updating metaData fieldID to normal property if it has fieldID starts with !P! or !PL!
+    updateMetaEmbeddedFieldID(metaFields);
+  }
+  updateFieldType(metaFields);
+
+  if (isDataObject) {
+    const compositeKeys: any[] = [];
+    const dataViewName = PCore.getDataTypeUtils().getSavableDataPage(classID);
+    const dataPageKeys = PCore.getDataTypeUtils().getDataPageKeys(dataViewName);
+    dataPageKeys?.forEach(item => (item.isAlternateKeyStorage ? compositeKeys.push(item.linkedField) : compositeKeys.push(item.keyName)));
+    if (compositeKeys.length) {
+      otherContext?.setCompositeKeys(compositeKeys);
+    }
+    if (otherContext) {
+      otherContext.fetchRowActionDetails = null;
+    }
+  }
+
+  const presetArray = [];
+  const rawMetadata = getPConnect().getRawMetadata().config;
+  const rawPresets = rawMetadata.presets;
+  const isMetaWithPresets = rawPresets && rawPresets.length !== 0;
+  const childrenIterator = isMetaWithPresets ? rawPresets : children;
+  const resolvedPresets = getPConnect().getConfigProps().presets;
+  let fields;
+  let tableConfig;
+  childrenIterator?.forEach((presetMeta, index) => {
+    const { configFields } = getTableConfigFromPresetMeta(
+      { ...presetMeta, label: resolvedPresets[index].label },
+      isMetaWithPresets,
+      getPConnect,
+      classID,
+      primaryFields,
+      metaFields
+    );
+    const pushToComponentsList = fieldType => {
+      listOfComponents.push(fieldType);
+    };
+    // read report columns response - in case of nonqueryable ignore the response and rely only on the fields configured at authoing time in presets
+    const reportColumnsSet = isQueryable ? getReportColumns(promisesResponseArray[1]) : new Set();
+
+    const configFieldSet = prepareConfigFields(configFields, pushToComponentsList);
+
+    // FIXME #EmbeddedPropertyPatch
+    // TODO: Remove this merge logic when the metadata response includes all optimized embedded page and pagelists
+    // merging configured embedded properties with metadata so that while preparing extra fields, config fields can get other properties from meta(eg: category, displayAsLink)
+    // get configured embedded properties metadata and get new mergedMetaFields
+    const configEmbeddedFieldsMeta = getConfigEmbeddedFieldsMeta(configFieldSet, classID);
+    const mergedMetaFields = mergeConfigEmbeddedFieldsMeta(configEmbeddedFieldsMeta, metaFields);
+
+    const extraFields = prepareExtraFields(
+      mergedMetaFields, // passing new merged meta fields which has meta of configured embedded fields of current preset
+      configFields,
+      configFieldSet,
+      reportColumnsSet,
+      classID,
+      showDynamicFields
+    );
+
+    if (isQueryable) {
+      updatePageFieldsConfig(configFields, classID);
+      preparePropertyMaps([...configFields, ...extraFields], classID, context);
+    }
+
+    const { getMappedProperty } = context;
+
+    fields = initializeColumns([...configFields, ...extraFields], getMappedProperty);
+    const patchQueryFields = preparePatchQueryFields(fields, isDataObject, classID);
+    const itemKey = getItemKey(fields);
+    tableConfig = { fieldDefs: fields, patchQueryFields, itemKey, isQueryable };
+  });
+  const meta = tableConfig;
+  setListContext({
+    meta,
+    presets: presetArray,
+    apiContext: {
+      ...apiContext
+    }
+  });
+};