@izara_frontend/service-schemas 1.0.1 → 1.0.2

package/src/getObjectSchema.js

@@ -0,0 +1,1341 @@
+import { useCallback, useEffect, useState, useRef } from "react";
+import {
+  validateObjType as validateObjTypeLib,
+  consts as schemaConsts,
+  utils as sharedSchemaUtils,
+  reformatObjectSchema
+} from "@izara_project/izara-shared-service-schemas"
+
+import lodash from "lodash";
+import { objectHash as hash } from "@izara_project/izara-shared-core";
+const { validateObjType, validateRelType } = validateObjTypeLib;
+
+
+import {
+  getObjectSchemaAllEndpoint,
+  getObjectLinksEndpoint,
+  getRefObjectRelationshipEndpoint,
+  getRelationshipSchemaEndpoint,
+  getLinkConfigEndpoint
+} from './endpoint'
+
+let schemaInitTools = null;
+let cachedEndpoints = {};
+
+
+export function initGetSchemaTools(initTools) {
+  cachedEndpoints = {};
+  schemaInitTools = initTools;
+
+  if (!schemaInitTools || !schemaInitTools.injectReducer || !schemaInitTools.store || !schemaInitTools.createPostsApi) {
+  } else {
+    const { injectReducer, store, createPostsApi } = schemaInitTools;
+
+    const endpoints = [
+      getObjectSchemaAllEndpoint,
+      getObjectLinksEndpoint,
+      getRefObjectRelationshipEndpoint,
+      getRelationshipSchemaEndpoint,
+      getLinkConfigEndpoint
+    ];
+
+
+    const postApi = createPostsApi(endpoints);
+    injectReducer(null, endpoints);
+
+    for (const endpoint of endpoints) {
+      const getSchemaFn = {
+        [endpoint.name]: async (params) => {
+          const result = await store.dispatch(
+            postApi.endpoints[endpoint.name].initiate(params)
+          );
+
+          if (result?.data) {
+            return result.data;
+          } else {
+            return null;
+          }
+        }
+      };
+
+      Object.assign(cachedEndpoints, getSchemaFn);
+    }
+  }
+
+}
+
+
+
+function createObjTypeConcat(objType) {
+  const validateObjTypeResult = validateObjType(objType);
+  if (validateObjTypeResult.errorsFound.length > 0) {
+    return [null, [`Invalid objType:${JSON.stringify(objType)}, ${validateObjTypeResult.errorsFound.join(", ")}`]]
+  }
+  return [`${objType.serviceTag}_${objType.objectType}`, []]
+}
+
+function explodedObjTypeConcat(objTypeConcat) {
+  return objTypeConcat.split("_");
+}
+
+// ...existing code...
+export function getObjectSchemaWithAllHierarchy() {
+  const { getObjectSchemaAll } = cachedEndpoints;
+
+  if (!getObjectSchemaAll) {
+    return [null, () => { }, { errorsFound: ["need to initialize initGetSchemaTools before use"] }];
+  }
+
+  const [result, setResult] = useState(null);
+  const [errorsFound, setErrorsFound] = useState([]);
+
+  // core executor that does the actual work and optionally updates hook state
+  // defaults to update the hook state; supports clearing state with `clearState`
+  const execute = useCallback(async (objType, { updateState = true, clearState = false } = {}) => {
+
+    // allow caller to clear current state before running
+    if (updateState && clearState) {
+      setResult(null);
+      setErrorsFound([]);
+    }
+    const seenObjTypeConcat = new Set();
+
+    async function getObjectSchemaWithAllHierarchyMain(currentObjType, seenSet, iter = 1) {
+      // validate depth
+      if (iter > 20) {
+        return [null, [`getObjectSchemaWithAllHierarchy Error objectType:${currentObjType?.objectType} Have more than ${20} hierarchy.`]];
+      }
+
+      // validate objType (some validators throw, some return errors)
+      try {
+        validateObjType(currentObjType);
+      } catch (err) {
+        return [null, [err.message]];
+      }
+
+      // create unique key for this objType
+      const [objTypeConcat, objKeyErr] = createObjTypeConcat(currentObjType);
+      if (objKeyErr.length) {
+        return [null, objKeyErr];
+      }
+
+      if (seenSet.has(objTypeConcat)) {
+        return [null, [`found duplicate objType in hierarchy ${objTypeConcat}, possible infinite loop`]];
+      } else {
+        seenSet.add(objTypeConcat);
+      }
+
+      // fetch schema
+      const objSchema = await getObjectSchemaAll(currentObjType);
+      if (!objSchema) {
+        if (iter === 1) {
+          return [null, [`not found objectSchema, Not found { serviceTag:${currentObjType.serviceTag}, objectType:${currentObjType.objectType} }`]];
+        }
+        return [null, [`not found objectSchema in hierarchy, Not found { serviceTag:${currentObjType.serviceTag}, objectType:${currentObjType.objectType} }`]];
+      }
+
+      // collect current
+      const collectedSchema = { [objTypeConcat]: objSchema };
+
+      // if extend, recurse and merge maps
+      if (objSchema.hasOwnProperty("extendObjType")) {
+        const [parentsObjSchema, parentObjSchemaErrors] = await getObjectSchemaWithAllHierarchyMain(
+          objSchema.extendObjType,
+          seenSet,
+          iter + 1,
+        );
+
+        if (parentObjSchemaErrors && parentObjSchemaErrors.length) {
+          return [null, parentObjSchemaErrors];
+        }
+
+        // merge parentMap into collected (parent entries may be deeper)
+        Object.assign(collectedSchema, parentsObjSchema);
+      }
+
+      return [collectedSchema, []];
+    }
+
+    try {
+
+      const [schema, errorsFound] = await getObjectSchemaWithAllHierarchyMain(objType, seenObjTypeConcat, 1);
+
+      if (updateState) {
+        if (errorsFound && errorsFound.length) {
+          setErrorsFound(errorsFound);
+          setResult(null);
+        } else {
+          setResult(schema);
+          setErrorsFound([]);
+        }
+      }
+      return [schema, errorsFound];
+    } catch (err) {
+      const msg = err?.message || String(err);
+
+      if (updateState) {
+        setErrorsFound([msg]);
+        setResult(null);
+      }
+      return [null, [msg]];
+    }
+  }, [cachedEndpoints]);
+
+  // run can be used two ways:
+  // 1) run(objType) -> updates hook state and returns Promise<[collected, errors]>
+  // 2) run().initiate(objType) -> does NOT touch hook state, returns Promise<[collected, errors]>
+  const run = useCallback((objType) => {
+    if (typeof objType === "undefined") {
+      return {
+        initiate: (objType) => execute(objType, { updateState: false })
+      };
+    }
+    // direct call: update state
+    return execute(objType, { updateState: true });
+  }, [execute]);
+
+
+  return [result, run, { errorsFound }];
+}
+
+
+export function getObjectLinks() {
+  const {
+    getObjectSchemaAll,
+    getObjectLinks: getObjectLinksSchema,
+    getRefObjectRelationship: getRefRelSchema,
+    getRelationshipSchema: getRelSchema
+  } = cachedEndpoints;
+
+  if (!getObjectSchemaAll || !getObjectLinksSchema || !getRefRelSchema || !getRelSchema) {
+    return [null, () => { }, { errorsFound: ["need to initialize initGetSchemaTools before use"] }];
+  }
+  const [, getObjectSchemaWithAllHierarchyFn] = getObjectSchemaWithAllHierarchy();
+
+
+  const [result, setResult] = useState(null);
+  const [errorsFound, setErrorsFound] = useState([]);
+
+
+  // core executor that does the actual work and optionally updates hook state
+  const execute = useCallback(async (objType, { updateState = true } = {}) => {
+
+    async function getObjectLinksMain(objType) {
+
+      // validate objType (some validators throw, some return errors)
+      try {
+        validateObjType(objType);
+      } catch (err) {
+        return [null, [err.message]];
+      }
+
+      let mainErrorsFound = [];
+
+      const mainObjTypeConcat = createObjTypeConcat(objType);
+
+      const [objectSchemaHierarChy, getSchemaErrors] = await getObjectSchemaWithAllHierarchyFn().initiate(objType);
+
+
+      if (getSchemaErrors.length || !objectSchemaHierarChy || !Object.keys(objectSchemaHierarChy).length) {
+        return [null, getSchemaErrors];
+      }
+
+      let returnLinks = [];
+      const linkTypeIds = new Set();
+
+      await Promise.all(
+        Object.keys(objectSchemaHierarChy).map(async (objTypeConcat) => {
+
+          const [serviceTag, objectType] = explodedObjTypeConcat(objTypeConcat);
+
+          let getObjLinksAndRefPromises = [];
+
+          getObjLinksAndRefPromises.push(getObjectLinksSchema({ serviceTag, objectType }));
+          getObjLinksAndRefPromises.push(getRefRelSchema({ serviceTag, objectType }));
+
+          const [objectLinks, refRelationshipsResult] = await Promise.all(getObjLinksAndRefPromises);
+
+          if (objectLinks && objectLinks?.length) {
+            for (const objectLink of objectLinks) {
+              let usedLink = objectLink;
+
+              if (objTypeConcat !== mainObjTypeConcat) {
+                usedLink = {
+                  ...objectLink,
+                  base: { ...objectLink.base, objType }
+                };
+              }
+
+              const usedLinkTypeId = hash([usedLink.base.objType, usedLink.other.objType, usedLink.relType, usedLink.base.direction]);
+
+              if (!linkTypeIds.has(usedLinkTypeId)) {
+                linkTypeIds.add(usedLinkTypeId);
+                returnLinks.push(usedLink);
+              }
+            }
+          }
+
+          if (refRelationshipsResult && Object.keys(refRelationshipsResult).length) {
+            await Promise.all(
+              Object.entries(refRelationshipsResult).map(async ([relTag, refData]) => {
+
+                let refRelSchemaResult = await getRelSchema(
+                  {
+                    serviceTag: refData.relationshipServiceTag,
+                    relationshipTag: relTag
+                  },
+                );
+
+
+                if (refRelSchemaResult) {
+                  const linkRecordsResult = sharedSchemaUtils.findLinksByObjType(
+                    { serviceTag, objectType },
+                    {
+                      serviceTag: refData.relationshipServiceTag,
+                      relationshipTag: relTag
+                    },
+                    refRelSchemaResult
+                  );
+
+
+
+                  if (linkRecordsResult.errorsFound.length > 0) {
+                    mainErrorsFound.push(...linkRecordsResult.errorsFound);
+                  }
+
+                  if (linkRecordsResult.result.length) {
+                    for (const linkRecord of linkRecordsResult.result) {
+                      let usedLink = linkRecord;
+                      if (objTypeConcat !== mainObjTypeConcat) {
+                        usedLink = {
+                          ...linkRecord,
+                          base: { ...linkRecord.base, objType }
+                        };
+                      }
+                      const usedLinkTypeId = hash([usedLink.base.objType, usedLink.other.objType, usedLink.relType, usedLink.base.direction]);
+
+                      if (!linkTypeIds.has(usedLinkTypeId)) {
+                        linkTypeIds.add(usedLinkTypeId);
+                        returnLinks.push(usedLink);
+                      }
+                    }
+                  } else {
+                    mainErrorsFound.push(`relationshipTag:'${relTag}' in service:'${refData.relationshipServiceTag}' not have objectType:'${objType.objectType}' in links`);
+                  }
+                } else {
+                  mainErrorsFound.push(`Not found relationshipTag:${relTag} in service:${refData.relationshipServiceTag}`);
+                }
+              }));
+          }
+        })
+      );
+
+      return [returnLinks, mainErrorsFound];
+    }
+
+    try {
+
+      const [schema, errorsFound] = await getObjectLinksMain(objType);
+
+      if (updateState) {
+        if (errorsFound && errorsFound.length) {
+          setErrorsFound(errorsFound);
+          setResult(null);
+        } else {
+          setResult(schema);
+          setErrorsFound([]);
+        }
+      }
+
+      return [schema, errorsFound];
+    } catch (err) {
+      const msg = err?.message || String(err);
+      if (updateState) {
+        setErrorsFound([msg]);
+        setResult(null);
+      }
+      return [null, [msg]];
+    }
+  }, [cachedEndpoints]);
+
+
+  // run can be used two ways:
+  // 1) run(objType) -> updates hook state and returns Promise<[collected, errors]>
+  // 2) run().initiate(objType) -> does NOT touch hook state, returns Promise<[collected, errors]>
+  const run = useCallback((objType) => {
+    if (typeof objType === "undefined") {
+      return {
+        initiate: (objType) => execute(objType, { updateState: false })
+      };
+    }
+    // direct call: update state
+    return execute(objType, { updateState: true });
+  }, [execute]);
+
+  return [result, run, { errorsFound }];
+}
+
+
+
+export function getRequiredOnCreateLinks() {
+  const [, getObjectLinksFn] = getObjectLinks();
+
+
+  const [result, setResult] = useState(null);
+  const [errorsFound, setErrorsFound] = useState([]);
+
+  // core executor that does the actual work and optionally updates hook state
+  const execute = useCallback(async (objType, { updateState = true } = {}) => {
+
+    async function getObjectLinksMain(objType) {
+      let returnLinks = [];
+
+      const [objectLinks, objectLinksErrors] = await getObjectLinksFn().initiate(objType);
+
+      if (objectLinksErrors?.length) {
+        return [[], objectLinksErrors];
+      }
+
+      if (objectLinks?.length) {
+        for (const objectLink of objectLinks) {
+          if (objectLink.base?.requiredOnCreate) {
+            returnLinks.push(objectLink);
+          }
+        }
+      }
+
+      return [returnLinks, []];
+    }
+
+    try {
+
+      const [schema, errorsFound] = await getObjectLinksMain(objType);
+
+      if (updateState) {
+        if (errorsFound && errorsFound.length) {
+          setErrorsFound(errorsFound);
+          setResult(null);
+        } else {
+          setResult(schema);
+          setErrorsFound([]);
+        }
+      }
+
+      return [schema, errorsFound];
+    } catch (err) {
+      const msg = err?.message || String(err);
+      if (updateState) {
+        setErrorsFound([msg]);
+        setResult(null);
+      }
+      return [null, [msg]];
+    }
+  }, [getObjectLinksFn]);
+
+
+
+  // run can be used two ways:
+  // 1) run(objType) -> updates hook state and returns Promise<[collected, errors]>
+  // 2) run().initiate(objType) -> does NOT touch hook state, returns Promise<[collected, errors]>
+  const run = useCallback((objType) => {
+    if (typeof objType === "undefined") {
+      return {
+        initiate: (objType) => execute(objType, { updateState: false })
+      };
+    }
+    // direct call: update state
+    return execute(objType, { updateState: true });
+  }, [execute]);
+
+  return [result, run, { errorsFound }];
+}
+
+
+export function getRelationshipSchema() {
+  const { getRelationshipSchema: getRelationshipSchemaEndpoint } = cachedEndpoints;
+
+  if (!getRelationshipSchemaEndpoint) {
+    return [null, () => { }, { errorsFound: ["need to initialize initGetSchemaTools before use"] }];
+  }
+
+  const [result, setResult] = useState(null);
+  const [errorsFound, setErrorsFound] = useState([]);
+
+
+  // core executor that does the actual work and optionally updates hook state
+  const execute = useCallback(async (relType, { updateState = true } = {}) => {
+
+    async function getRelationshipSchemaMain(relType) {
+
+      const relationshipSchema = await getRelationshipSchemaEndpoint(relType);
+      return [relationshipSchema, []];
+    }
+
+    try {
+
+      const [schema, errorsFound] = await getRelationshipSchemaMain(relType);
+
+      if (updateState) {
+        if (errorsFound && errorsFound.length) {
+          setErrorsFound(errorsFound);
+          setResult(null);
+        } else {
+          setResult(schema);
+          setErrorsFound([]);
+        }
+      }
+
+      return [schema, errorsFound];
+    } catch (err) {
+      const msg = err?.message || String(err);
+      if (updateState) {
+        setErrorsFound([msg]);
+        setResult(null);
+      }
+      return [null, [msg]];
+    }
+  }, [cachedEndpoints]);
+
+
+
+  // run can be used two ways:
+  // 1) run(objType) -> updates hook state and returns Promise<[collected, errors]>
+  // 2) run().initiate(objType) -> does NOT touch hook state, returns Promise<[collected, errors]>
+  const run = useCallback((objType) => {
+    if (typeof objType === "undefined") {
+      return {
+        initiate: (objType) => execute(objType, { updateState: false })
+      };
+    }
+    // direct call: update state
+    return execute(objType, { updateState: true });
+  }, [execute]);
+
+  return [result, run, { errorsFound }];
+}
+
+
+export function getObjSchemaWithOutHierarchy() {
+  const { getObjectSchemaAll } = cachedEndpoints;
+
+  if (!getObjectSchemaAll) {
+    return [null, () => { }, { errorsFound: ["need to initialize initGetSchemaTools before use"] }];
+  }
+
+  const [result, setResult] = useState(null);
+  const [errorsFound, setErrorsFound] = useState([]);
+
+
+  // core executor that does the actual work and optionally updates hook state
+  const execute = useCallback(async (objType, { updateState = true } = {}) => {
+
+    async function getObjSchemaWithOutHierarchyMain(objType) {
+      const objSchema = await getObjectSchemaAll(objType);
+      return [objSchema, []];
+    }
+
+    try {
+
+      const [schema, errorsFound] = await getObjSchemaWithOutHierarchyMain(objType);
+
+      if (updateState) {
+        if (errorsFound && errorsFound.length) {
+          setErrorsFound(errorsFound);
+          setResult(null);
+        } else {
+          setResult(schema);
+          setErrorsFound([]);
+        }
+      }
+
+      return [schema, errorsFound];
+    } catch (err) {
+      const msg = err?.message || String(err);
+      if (updateState) {
+        setErrorsFound([msg]);
+        setResult(null);
+      }
+      return [null, [msg]];
+    }
+  }, [cachedEndpoints]);
+
+
+
+  // run can be used two ways:
+  // 1) run(objType) -> updates hook state and returns Promise<[collected, errors]>
+  // 2) run().initiate(objType) -> does NOT touch hook state, returns Promise<[collected, errors]>
+  const run = useCallback((objType) => {
+    if (typeof objType === "undefined") {
+      return {
+        initiate: (objType) => execute(objType, { updateState: false })
+      };
+    }
+    // direct call: update state
+    return execute(objType, { updateState: true });
+  }, [execute]);
+
+  return [result, run, { errorsFound }];
+}
+
+export function getObjSchemaWithHierarchy() {
+
+  const [, getObjectSchemaWithAllHierarchyFn] = getObjectSchemaWithAllHierarchy();
+
+  const [result, setResult] = useState(null);
+  const [errorsFound, setErrorsFound] = useState([]);
+
+
+  // core executor that does the actual work and optionally updates hook state
+  const execute = useCallback(async (objType, { updateState = true } = {}) => {
+
+    async function getObjSchemaWithHierarchyMain(objType) {
+      const [objectSchemaHierarChy, getSchemaErrors] = await getObjectSchemaWithAllHierarchyFn().initiate(objType);
+
+      if (getSchemaErrors.length) {
+        return [null, getSchemaErrors];
+      } else {
+
+        const mergeCount = Object.keys(objectSchemaHierarChy).length;
+
+        if (mergeCount === 1) {
+          return [Object.values(objectSchemaHierarChy)[0], getSchemaErrors];
+        } else if (mergeCount > 1) {
+
+          let mainObjType = objType;
+          let mergeObjSchema = {};
+
+          // iterate to merge all objectSchema in hierarchy
+          for (let i = 0; i < mergeCount; i++) {
+
+            const [objTypeConcat] = createObjTypeConcat(mainObjType);
+            const objectSchema = objectSchemaHierarChy[objTypeConcat];
+
+
+            if (i === 0) {
+              mergeObjSchema = lodash.cloneDeep(objectSchema);
+
+            } else {
+              // change mainObjType every time in loop
+              if (mergeObjSchema.hasOwnProperty("extendObjType")) {
+                mainObjType = mergeObjSchema.extendObjType;
+                const [parentObjTypeConcat, errorsCreateObjTypeConcat] = createObjTypeConcat(mergeObjSchema.extendObjType);
+
+                if (errorsCreateObjTypeConcat.length) {
+                  return [null, errorsCreateObjTypeConcat];
+                }
+
+                const parentObjSchema = objectSchemaHierarChy[parentObjTypeConcat];
+
+                if (!parentObjSchema) {
+                  return [null, [`extendObjType:${objType.objectType} Not found parent. => ${JSON.stringify(mergeObjSchema.extendObjType)}`]]
+                }
+
+                // merge canCreate if not exists in child objectSchema
+                if (!mergeObjSchema.canDelete && parentObjSchema.hasOwnProperty("canDelete")) {
+                  mergeObjSchema.canDelete = parentObjSchema.canDelete;
+                }
+
+                // validate and merge identifiers
+                if (parentObjSchema.hasOwnProperty("identifiers") && parentObjSchema.hasOwnProperty("extendObjType")) {
+                  return [null, ["mergeExtendObjSchema:parent objectSchema should not have identifiers because have extendObjType."]];
+                } else if (!parentObjSchema.hasOwnProperty("identifiers") && !parentObjSchema.hasOwnProperty("extendObjType")) {
+                  return [null, ["mergeExtendObjSchema:invalid parent objectSchema missing identifiers."]];
+                } else {
+                  mergeObjSchema.identifiers = parentObjSchema.identifiers;
+                }
+
+                for (const [parentFieldName, parentFieldNameProp] of Object.entries(parentObjSchema.fieldNames)) {
+                  const existingFieldNamePropInParent = mergeObjSchema.fieldNames[parentFieldName];
+
+                  if (existingFieldNamePropInParent) {
+                    // Validate that child fieldName only has storageResourceTags if it exists
+                    const isValidChildFieldName =
+                      Object.keys(existingFieldNamePropInParent).length === 0 ||
+                      (Object.keys(existingFieldNamePropInParent).length === 1 && existingFieldNamePropInParent.hasOwnProperty("storageResourceTags"));
+
+                    if (!isValidChildFieldName) {
+                      return [null, [`objectSchema:${mergeObjSchema.objectType} merge fieldName:${parentFieldName} invalid, child fieldName can only have storageResourceTags when merging.`]];
+                    }
+
+                    // Merge parent fieldName properties into child, concatenating storageResourceTags
+                    for (const [parentFieldNameKey, parentFieldNameValue] of Object.entries(parentFieldNameProp)) {
+                      if (parentFieldNameKey === "storageResourceTags") {
+                        // merge storageResourceTags from parent and child, preserving order and uniqueness
+                        const childStorageTags = existingFieldNamePropInParent.storageResourceTags || [];
+                        const parentStorageTags = parentFieldNameValue || [];
+                        existingFieldNamePropInParent.storageResourceTags = [...new Set([...childStorageTags, ...parentStorageTags])];
+                      } else {
+                        existingFieldNamePropInParent[parentFieldNameKey] = parentFieldNameValue;
+                      }
+                    }
+                  } else {
+                    // Add parent fieldName to child if it doesn't exist
+                    mergeObjSchema.fieldNames[parentFieldName] = parentFieldNameProp;
+                  }
+                }
+
+
+                // Merge addOnDataStructure from parent to child objectSchema
+                if (parentObjSchema.hasOwnProperty("addOnDataStructure") && parentObjSchema.addOnDataStructure?.length) {
+                  for (let parentAddOnData of parentObjSchema.addOnDataStructure) {
+                    // Merge versionedData from parent to child objectSchema
+                    if (parentAddOnData.type === "versionedData") {
+
+                      // check duplicate versionedDataLabel
+                      let duplicateVersionedData = mergeObjSchema.addOnDataStructure?.find(
+                        (childAddOnData) =>
+                          childAddOnData.type === "versionedData" &&
+                          childAddOnData.versionedDataLabel === parentAddOnData.versionedDataLabel
+                      );
+
+                      if (duplicateVersionedData) {
+                        return [null, [`objectSchema:${mergeObjSchema.objectType} invalid. Found duplicate versionedDataLabel ${parentAddOnData.versionedDataLabel} between parent and child objectSchema`]];
+                      }
+
+                      // Add parent versionedData to child if not exists
+                      if (!mergeObjSchema.addOnDataStructure) {
+                        mergeObjSchema.addOnDataStructure = [];
+                      }
+                      mergeObjSchema.addOnDataStructure.push(lodash.cloneDeep(parentAddOnData));
+                    }
+                  }
+                }
+
+                // after merge versionedData will validate duplicate fieldName bwt main fieldNames and versionedData fieldNames
+                let fieldNameList = new Set(Object.keys(mergeObjSchema.fieldNames));
+                if (mergeObjSchema.addOnDataStructure?.length) {
+                  for (let addOnData of mergeObjSchema.addOnDataStructure) {
+                    if (addOnData.type === "versionedData") {
+                      for (let fieldName in addOnData.fieldNames) {
+                        if (fieldNameList.has(fieldName)) {
+                          return [null, [`objectSchema:${mergeObjSchema.objectType} invalid while merge extend. Found duplicate fieldName ${fieldName} between main fieldNames and versionedData fieldNames`]];
+                        } else {
+                          fieldNameList.add(fieldName);
+                        }
+                      }
+                    }
+                  }
+                }
+
+                // add storageResources from parent if not exists in child objectSchema
+                let currentStorageResourcesList = Object.keys(mergeObjSchema.storageResources);
+                for (let [parentStorageResourceName, parentStorageResourceProp] of Object.entries(parentObjSchema.storageResources)) {
+                  if (!currentStorageResourcesList.includes(parentStorageResourceName)) {
+                    Object.assign(mergeObjSchema.storageResources, { [parentStorageResourceName]: parentStorageResourceProp });
+                  } else {
+                    // if found storageResource in both parent and child will validate that storageResource will have same data
+
+                    if (hash(mergeObjSchema.storageResources[parentStorageResourceName]) !== hash(parentStorageResourceProp)) {
+                      return [null, [`objectSchema:${mergeObjSchema.objectType} storageResources.${parentStorageResourceName} not match with parent objectSchema`]];
+                    }
+                  }
+                }
+
+              }
+            }
+          }
+
+          // validate duplicate storageResources value data and dynamoDB tableName
+          const storageHashList = new Set();
+          const dynamoDBHashList = new Set();
+          const mergedErrors = [];
+
+          if (mergeObjSchema?.storageResources) {
+            for (const storageResource of Object.values(mergeObjSchema.storageResources)) {
+              const storageResourceHash = hash(storageResource);
+
+              if (storageHashList.has(storageResourceHash)) {
+                mergedErrors.push(`Should not have duplicate storageResources value data`);
+                break;
+              } else {
+                storageHashList.add(storageResourceHash);
+              }
+
+              if (storageResource.storageType === schemaConsts.STORAGE_TYPES.dynamoDB) {
+                const dynamoDBTableNameAndServiceTag = `${storageResource.tableName}_${storageResource.serviceTag}`
+                if (dynamoDBHashList.has(dynamoDBTableNameAndServiceTag)) {
+                  mergedErrors.push(`Should not have duplicate tableName inside storageResources`);
+                  break;
+                } else {
+                  dynamoDBHashList.add(dynamoDBTableNameAndServiceTag);
+                }
+              }
+            }
+          }
+
+          if (mergedErrors.length) {
+            return [null, mergedErrors];
+          } else {
+            // merge all schema
+            return [mergeObjSchema, []];
+          }
+
+        } else {
+          return [null, []];
+        }
+      }
+    }
+
+    try {
+
+      const [schema, errorsFound] = await getObjSchemaWithHierarchyMain(objType);
+
+      if (updateState) {
+        if (errorsFound && errorsFound.length) {
+          setErrorsFound(errorsFound);
+          setResult(null);
+        } else {
+          setResult(schema);
+          setErrorsFound([]);
+        }
+      }
+
+      return [schema, errorsFound];
+    } catch (err) {
+      const msg = err?.message || String(err);
+      if (updateState) {
+        setErrorsFound([msg]);
+        setResult(null);
+      }
+      return [null, [msg]];
+    }
+  }, [getObjectSchemaWithAllHierarchyFn]);
+
+
+
+  // run can be used two ways:
+  // 1) run(objType) -> updates hook state and returns Promise<[collected, errors]>
+  // 2) run().initiate(objType) -> does NOT touch hook state, returns Promise<[collected, errors]>
+  const run = useCallback((objType) => {
+    if (typeof objType === "undefined") {
+      return {
+        initiate: (objType) => execute(objType, { updateState: false })
+      };
+    }
+    // direct call: update state
+    return execute(objType, { updateState: true });
+  }, [execute]);
+
+  return [result, run, { errorsFound }];
+}
+
+export function getObjSchemaCombineFieldNames() {
+
+  const [, getObjSchemaWithHierarchyFn] = getObjSchemaWithHierarchy();
+
+  const [result, setResult] = useState(null);
+  const [errorsFound, setErrorsFound] = useState([]);
+
+
+  // core executor that does the actual work and optionally updates hook state
+  const execute = useCallback(async (objType, { updateState = true } = {}) => {
+
+    async function getObjSchemaCombineFieldNamesMain(objType) {
+      const [objSchema, objSchemaErrors] = await getObjSchemaWithHierarchyFn().initiate(objType);
+
+      if (objSchemaErrors.length) {
+        return [null, objSchemaErrors];
+      }
+
+      const reformatedObjSchema = generateObjectSchemaForCombineFieldNames(objSchema)
+      return [reformatedObjSchema, []];
+    }
+
+    try {
+
+      const [schema, errorsFound] = await getObjSchemaCombineFieldNamesMain(objType);
+
+      if (updateState) {
+        if (errorsFound && errorsFound.length) {
+          setErrorsFound(errorsFound);
+          setResult(null);
+        } else {
+          setResult(schema);
+          setErrorsFound([]);
+        }
+      }
+
+      return [schema, errorsFound];
+    } catch (err) {
+      const msg = err?.message || String(err);
+      if (updateState) {
+        setErrorsFound([msg]);
+        setResult(null);
+      }
+      return [null, [msg]];
+    }
+  }, [getObjSchemaWithHierarchyFn]);
+
+
+
+  // run can be used two ways:
+  // 1) run(objType) -> updates hook state and returns Promise<[collected, errors]>
+  // 2) run().initiate(objType) -> does NOT touch hook state, returns Promise<[collected, errors]>
+  const run = useCallback((objType) => {
+    if (typeof objType === "undefined") {
+      return {
+        initiate: (objType) => execute(objType, { updateState: false })
+      };
+    }
+    // direct call: update state
+    return execute(objType, { updateState: true });
+  }, [execute]);
+
+  return [result, run, { errorsFound }];
+}
+
+
+
+export function getLinkConfig() {
+  const { getLinkConfig: getLinkConfigEndpoint } = cachedEndpoints;
+
+  if (!getLinkConfigEndpoint) {
+    return [null, () => { }, { errorsFound: ["need to initialize initGetSchemaTools before use"] }];
+  }
+
+  const [, getSchemaAllHierarchyFn] = getObjectSchemaWithAllHierarchy();
+
+  const [result, setResult] = useState(null);
+  const [errorsFound, setErrorsFound] = useState([]);
+
+
+  // core executor that does the actual work and optionally updates hook state
+  const execute = useCallback(async (firstObjType, secondObjType, relType, direction, settings = { getAllLinks: false, getRawLink: false, getOriginalLink: true }, { updateState = true } = {}) => {
+
+    async function getLinkConfigMain(firstObjType, secondObjType, relType, direction, settings = { getAllLinks: false, getRawLink: false, getOriginalLink: true }) {
+      let errorsFound = [];
+      if (!direction || typeof direction !== "string" || (direction !== "from" && direction !== "to")) {
+        return [null, ['getLinkConfigByLinkTypeId invalid direction']];
+      }
+
+      const firstObjTypeValidation = validateObjType(firstObjType);
+      if (firstObjTypeValidation.errorsFound.length > 0) {
+        errorsFound.push(...firstObjTypeValidation.errorsFound);
+      }
+
+      const secondObjTypeValidation = validateObjType(secondObjType);
+      if (secondObjTypeValidation.errorsFound.length > 0) {
+        errorsFound.push(...secondObjTypeValidation.errorsFound);
+      }
+
+      const relTypeValidation = validateRelType(relType);
+      if (relTypeValidation.errorsFound.length > 0) {
+        errorsFound.push(...relTypeValidation.errorsFound);
+      }
+
+      if (errorsFound.length) {
+        return [null, errorsFound];
+      }
+
+
+      let linkConfigs = [];
+
+      // contain hierarchy of each objType
+      let firstObjTypeConcatHierarchy = [];
+      let secondObjTypeConcatHierarchy = [];
+
+      if (settings.getOriginalLink) {
+
+        const linkConfig = await getLinkConfigEndpoint({ firstObjType, secondObjType, relType, direction });
+        if (linkConfig) {
+          return [linkConfig, []];
+        } else {
+          return [null, []];
+        }
+
+      } else {
+        const [firstObjSchemaHie, secondObjSchemaHie] = await Promise.all([
+          getSchemaAllHierarchyFn().initiate(firstObjType),
+          getSchemaAllHierarchyFn().initiate(secondObjType)
+        ]);
+
+        if (!firstObjSchemaHie[0] || !secondObjSchemaHie[0]
+          || (typeof (firstObjSchemaHie[0]) !== 'object') || (typeof (secondObjSchemaHie[0]) !== 'object')
+          || !Object.keys(firstObjSchemaHie[0]).length || !Object.keys(secondObjSchemaHie[0]).length
+        ) {
+
+          return [null, ['getLinkConfig not found objSchema of some objType']];
+        }
+
+
+        firstObjTypeConcatHierarchy = Object.keys(firstObjSchemaHie[0]);
+        secondObjTypeConcatHierarchy = Object.keys(secondObjSchemaHie[0]);
+
+        const firstObjtTypeHie = firstObjTypeConcatHierarchy.map(objTypeConcat => {
+          const [firstServiceTag, firstObjectType] = explodedObjTypeConcat(objTypeConcat);
+          return { serviceTag: firstServiceTag, objectType: firstObjectType };
+        });
+
+        const secondObjTypeHie = secondObjTypeConcatHierarchy.map(objTypeConcat => {
+          const [firstServiceTag, firstObjectType] = explodedObjTypeConcat(objTypeConcat);
+          return { serviceTag: firstServiceTag, objectType: firstObjectType };
+        });
+
+
+        const linkConfigPromises = [];
+        for (const firstObject of firstObjtTypeHie) {
+          for (const secondObject of secondObjTypeHie) {
+            linkConfigPromises.push(getLinkConfigEndpoint({ firstObjType: firstObject, secondObjType: secondObject, relType, direction }));
+          }
+        }
+
+        const linkConfigPromiseResult = await Promise.all(linkConfigPromises);
+        linkConfigs = linkConfigPromiseResult.filter(Boolean);
+      }
+
+      let overWriteBaseObjTypeLinkConfigs = [];
+      // if getRawLink === true then will return raw link if false will refactor objType of link
+      if (settings.getRawLink === false) {
+
+        for (const linkConfig of linkConfigs) {
+          const useLinkConfig = lodash.cloneDeep(linkConfig);
+
+          const [fromObjTypeConcat] = createObjTypeConcat(linkConfig.from.objType);
+          const [toObjTypeConcat] = createObjTypeConcat(linkConfig.to.objType);
+
+          if (direction === 'from') {
+            // if direction === from compare with first - from, second - to
+            if (firstObjTypeConcatHierarchy.includes(fromObjTypeConcat) && secondObjTypeConcatHierarchy.includes(toObjTypeConcat)) {
+              useLinkConfig.from.objType = firstObjType;
+              useLinkConfig.to.objType = secondObjType;
+            }
+          } else {
+            // if direction === to compare with first - to, second - from
+            if (firstObjTypeConcatHierarchy.includes(toObjTypeConcat) && secondObjTypeConcatHierarchy.includes(fromObjTypeConcat)) {
+              useLinkConfig.from.objType = secondObjType;
+              useLinkConfig.to.objType = firstObjType;
+            }
+          }
+          overWriteBaseObjTypeLinkConfigs.push(useLinkConfig);
+        }
+        linkConfigs = overWriteBaseObjTypeLinkConfigs;
+      }
+
+      if (settings.getAllLinks) {
+        if (linkConfigs.length) {
+          return [linkConfigs, errorsFound];
+        } else {
+          return [null, errorsFound];
+        }
+      } else {
+        if (linkConfigs.length) {
+          return [linkConfigs[0], errorsFound];
+        } else {
+          return [null, errorsFound];
+        }
+      }
+    }
+
+    try {
+      const [schema, errorsFound] = await getLinkConfigMain(firstObjType, secondObjType, relType, direction, settings);
+      if (updateState) {
+        if (errorsFound && errorsFound.length) {
+          setErrorsFound(errorsFound);
+          setResult(null);
+        } else {
+          setResult(schema);
+          setErrorsFound([]);
+        }
+      }
+
+      return [schema, errorsFound];
+    } catch (err) {
+      const msg = err?.message || String(err);
+      if (updateState) {
+        setErrorsFound([msg]);
+        setResult(null);
+      }
+      return [null, [msg]];
+    }
+  }, [cachedEndpoints]);
+
+
+
+  // run can be used two ways:
+  // 1) run(objType) -> updates hook state and returns Promise<[collected, errors]>
+  // 2) run().initiate(objType) -> does NOT touch hook state, returns Promise<[collected, errors]>
+  const run = useCallback((...params) => {
+    // when called with no args return the initiate helper
+    if (params.length === 0) {
+      return {
+        initiate: (...initParams) => execute(...initParams, { updateState: false })
+      };
+    }
+    // direct call: update state
+    return execute(...params, { updateState: true });
+  }, [execute]);
+
+  return [result, run, { errorsFound }];
+}
+
+
+export function getObjectLinksWithRequestProperties() {
+
+  const [, getObjectLinksFnRaw] = getObjectLinks();
+  const [, getLinkConfigFnRaw] = getLinkConfig();
+
+  const getObjectLinksFn = useCallback(() => getObjectLinksFnRaw(), [getObjectLinksFnRaw]);
+  const getLinkConfigFn = useCallback(() => getLinkConfigFnRaw(), [getLinkConfigFnRaw]);
+
+
+  const [result, setResult] = useState(null);
+  const [errorsFound, setErrorsFound] = useState([]);
+
+
+  // core executor that does the actual work and optionally updates hook state
+  const execute = useCallback(async (objType, { updateState = true } = {}) => {
+
+    async function getObjectLinksWithRequestPropertiesMain(objType) {
+
+      // validate objType (some validators throw, some return errors)
+      try {
+        validateObjType(objType);
+      } catch (err) {
+        return [null, [err.message]];
+      }
+      let returnLinks = [];
+      let mainErrorsFound = [];
+
+      const mainObjTypeConcat = createObjTypeConcat(objType);
+
+      const [objectLinks, getSchemaErrors] = await getObjectLinksFn().initiate(objType);
+
+      if (getSchemaErrors?.length) {
+        return [[], getSchemaErrors];
+      }
+
+      if (objectLinks?.length) {
+        await Promise.all(objectLinks.map(async (objectLink) => {
+          let newLink = { ...objectLink };
+
+
+          const [objectLinkConfig] = await getLinkConfigFn().initiate(
+            objectLink.base.objType,
+            objectLink.other.objType,
+            objectLink.relType,
+            objectLink.base.direction
+          );
+
+          if (objectLinkConfig && objectLinkConfig.requestProperties) {
+            Object.assign(newLink, { requestProperties: objectLinkConfig.requestProperties });
+          }
+
+          returnLinks.push(newLink);
+        }));
+      }
+
+
+
+      return [{ [mainObjTypeConcat]: returnLinks }, mainErrorsFound];
+    }
+
+    try {
+
+      const [schema, errorsFound] = await getObjectLinksWithRequestPropertiesMain(objType);
+
+      if (updateState) {
+        if (errorsFound && errorsFound.length) {
+          setErrorsFound(errorsFound);
+          setResult(null);
+        } else {
+          setResult(schema);
+          setErrorsFound([]);
+        }
+      }
+
+      return [schema, errorsFound];
+    } catch (err) {
+      const msg = err?.message || String(err);
+      if (updateState) {
+        setErrorsFound([msg]);
+        setResult(null);
+      }
+      return [null, [msg]];
+    }
+  }, [getLinkConfigFnRaw, getObjectLinksFnRaw]);
+
+
+  // run can be used two ways:
+  // 1) run(objType) -> updates hook state and returns Promise<[collected, errors]>
+  // 2) run().initiate(objType) -> does NOT touch hook state, returns Promise<[collected, errors]>
+  const run = useCallback((objType) => {
+    if (typeof objType === "undefined") {
+      return {
+        initiate: (objType) => execute(objType, { updateState: false })
+      };
+    }
+    // direct call: update state
+    return execute(objType, { updateState: true });
+  }, [execute]);
+
+  return [result, run, { errorsFound }];
+}
+
+export function collectObjectLinksWithRequestProperties() {
+
+  const [, getObjectLinksWithRequestPropertiesFn] = getObjectLinksWithRequestProperties();
+
+  const [result, setResult] = useState(null);
+  const [errorsFound, setErrorsFound] = useState([]);
+
+
+
+  // ref to always read latest result inside async functions (avoids stale closures)
+  const resultRef = useRef(result);
+  useEffect(() => { resultRef.current = result; }, [result]);
+
+  // core executor that does the actual work and optionally updates hook state
+  const execute = useCallback(async (objType, { updateState = true } = {}) => {
+
+    async function collectObjectLinksWithRequestPropertiesMain(objType) {
+
+      // validate objType (some validators throw, some return errors)
+      try {
+        validateObjType(objType);
+      } catch (err) {
+        return [null, [err.message]];
+      }
+
+      // compute mainObjTypeConcat and validate
+      const [mainObjTypeConcat, mainObjTypeErrors] = createObjTypeConcat(objType);
+      if (mainObjTypeErrors && mainObjTypeErrors.length) {
+        return [null, mainObjTypeErrors];
+      }
+
+      // short-circuit: if updateState and we already have this objType in result, return cached value
+      if (updateState && resultRef.current && resultRef.current.hasOwnProperty(mainObjTypeConcat)) {
+        return [{ [mainObjTypeConcat]: resultRef.current[mainObjTypeConcat] }, []];
+      }
+
+
+
+      const [objectLinks, getSchemaErrors] = await getObjectLinksWithRequestPropertiesFn().initiate(objType);
+
+
+      return [objectLinks, getSchemaErrors];
+    }
+
+    try {
+
+
+      const [schema, errorsFound] = await collectObjectLinksWithRequestPropertiesMain(objType);
+
+      if (updateState) {
+        if (errorsFound && errorsFound.length) {
+          setErrorsFound(errorsFound);
+          setResult(null);
+        } else {
+          const [currentObjTypeConcat] = createObjTypeConcat(objType);
+
+          setResult(prev => {
+            // nothing to add
+            if (!schema || !Object.keys(schema).length) return prev;
+
+            // first-time fill
+            if (!prev) return schema;
+
+            // already have this objType => no update
+            if (prev.hasOwnProperty(currentObjTypeConcat)) return prev;
+
+            // merge but return a NEW object to trigger React update (do not mutate prev)
+            return { ...prev, ...schema };
+          });
+
+          setErrorsFound([]);
+        }
+      }
+
+      return [schema, errorsFound];
+    } catch (err) {
+      const msg = err?.message || String(err);
+      if (updateState) {
+        setErrorsFound([msg]);
+        setResult(null);
+      }
+      return [null, [msg]];
+    }
+  }, [getObjectLinksWithRequestPropertiesFn]);
+
+
+  // run can be used two ways:
+  // 1) run(objType) -> updates hook state and returns Promise<[collected, errors]>
+  // 2) run().initiate(objType) -> does NOT touch hook state, returns Promise<[collected, errors]>
+  const run = useCallback((objType) => {
+    if (typeof objType === "undefined") {
+      return {
+        initiate: (objType) => execute(objType, { updateState: false }),
+        clear: () => { setResult(null); setErrorsFound([]); }
+      };
+    }
+    // direct call: update state
+    return execute(objType, { updateState: true });
+  }, [execute]);
+
+  return [result, run, { errorsFound }];
+}
+
+
+
+
+/**
+ * TODO: need to use function inside reformatObjectSchema lib instead. create in this cause need to fix bug first
+ * create object schema that already combine fieldNames between main objectSchema and addOnDataStructure.type=versionedData
+ *
+ * @param {Object} objSchema
+ * @returns {Object}            - objectSchema that has property for case update
+ */
+function generateObjectSchemaForCombineFieldNames(useObjectSchema) {
+
+  // generate data for case update
+  let initReturnObj = {
+    objectType: useObjectSchema.objectType,
+    fieldNames: { ...useObjectSchema.fieldNames },
+    canDelete: useObjectSchema.canDelete,
+    storageResources: { ...useObjectSchema.storageResources }
+  };
+
+  if (useObjectSchema.extendObjType) {
+    Object.assign(initReturnObj, { extendObjType: useObjectSchema.extendObjType });
+  }
+
+  if (useObjectSchema.identifiers) {
+    Object.assign(initReturnObj, { identifiers: useObjectSchema.identifiers });
+    Object.assign(
+      initReturnObj,
+      { identifierFieldNames: reformatObjectSchema.getUsedFieldNamesOfIdentifiers(useObjectSchema.identifiers) }
+    );
+  }
+
+  // add fieldNames from versionedData
+  if (useObjectSchema.addOnDataStructure?.length) {
+    let versionedDataLabels = [];
+    // versionedDataField_ceo_versionedDataId
+    for (let addOn of useObjectSchema.addOnDataStructure) {
+      if (addOn.type === "versionedData") {
+        // add default fieldNames of versionedData to main fieldNames
+        Object.assign(
+          initReturnObj.fieldNames,
+          reformatObjectSchema.defaultVersionedDataFieldNames(addOn.versionedDataLabel, addOn.storageResourceTag)
+        );
+
+        // add each versionedData fieldName to main fieldNames
+        for (let [versionedFieldName, fieldNameData] of Object.entries(addOn.fieldNames)) {
+          Object.assign(initReturnObj.fieldNames, {
+            [versionedFieldName]: {
+              ...fieldNameData,
+              versionedDataLabel: addOn.versionedDataLabel,
+              storageResourceTags: [addOn.storageResourceTag]
+            }
+          });
+        }
+        versionedDataLabels.push(addOn.versionedDataLabel);
+      }
+    }
+
+    if (versionedDataLabels.length) {
+      initReturnObj.versionedDataLabels = versionedDataLabels;
+    }
+  }
+
+  return initReturnObj;
+}