@izara_project/izara-shared-service-schemas 1.0.21 → 1.0.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izara_project/izara-shared-service-schemas",
-  "version": "1.0.21",
+  "version": "1.0.23",
   "description": "Shared Libraries frontend/backend for Service Schemas",
   "main": "index.js",
   "scripts": {

package/src/Consts.js

@@ -300,5 +300,8 @@ module.exports = {
   HANDLER,
   HANDLER_LIST: Object.values(HANDLER),
   FIELDNAME_TYPES,
-  ALLOW_FIELDNAME_TYPES
+  ALLOW_FIELDNAME_TYPES,
+
+  OBJECT_SCHEMA_BUCKET_NAME: 'object-schema',
+  SUPPLY_SCHEMA_BUCKET_NAME: "schema-supply",
 }

package/src/GetObjectSchema.js

@@ -25,30 +25,32 @@ const NoRetryError = izaraCore.NoRetryError;
 const { validateObject } = izaraCore.validator;
 
 const { basicFieldNameSchema } = require("./libs/BasicValidatorSchema");
-const { validateRelType, validateObjType } = require('./libs/ValidateObjType');
+const { validateRelType, validateObjType, validateFlowType } = require('./libs/ValidateObjType');
 
 const { findLinksByObjType, createLinkTypeId } = require("./Utils");
-const { SCHEMA_NAME, STORAGE_TYPES } = require('./Consts');
+const { SCHEMA_NAME, STORAGE_TYPES, OBJECT_SCHEMA_BUCKET_NAME } = require('./Consts');
 const {
   generateObjectSchemaForCreate,
   generateObjectSchemaForUpdate,
   generateObjectSchemaForCombineFieldNames
 } = require('./libs/ReformatObjectSchema');
+
 /**
  * Retrieves a specific object schema from S3.
  *
  * @param {Function} getSchemaFn - Function to fetch the schema from S3.
  * @param {object} objType - The object type information.
  * @param {string} objType.objectType - The type of the object.
+ * @param {string} bucketName - bucketName to getSchema
  * @param {boolean} [getExtendObType=false] - Whether to include extended object type data.
  * @returns {Promise<object>} - The object schema, optionally merged with extended object type data.
  */
 async function getObjSchemaS3(
   getSchemaFn,
   objType,
+  bucketName = OBJECT_SCHEMA_BUCKET_NAME,
   getExtendObType = false,
 ) {
-
   try {
     validateObjType(objType);
   } catch (error) {
@@ -63,7 +65,7 @@ async function getObjSchemaS3(
     getParams: objType
   }
 
-  let objSchema = await getSchemaFn(getDataParams);
+  let objSchema = await getSchemaFn(getDataParams, bucketName);
   if (!objSchema) {
     // return objSchema;
     return {
@@ -105,8 +107,8 @@ async function getObjSchemaS3(
  * @returns {Promise<object>} - The object schema, optionally merged with extended object type data.
  * @see  {@link getObjSchemaS3}
  */
-async function getObjSchemaWithHierarchy(getSchemaFn, objType) {
-  return await getObjSchemaS3(getSchemaFn, objType, true);
+async function getObjSchemaWithHierarchy(getSchemaFn, objType, bucketName = OBJECT_SCHEMA_BUCKET_NAME) {
+  return await getObjSchemaS3(getSchemaFn, objType, bucketName, true);
 }
 
 /**
@@ -117,8 +119,8 @@ async function getObjSchemaWithHierarchy(getSchemaFn, objType) {
  * @returns {Promise<object>} - The object schema without extended hierarchical data.
  * @see {@link getObjSchemaS3}
  */
-async function getObjSchemaWithoutHierarchy(getSchemaFn, objType) {
-  return await getObjSchemaS3(getSchemaFn, objType, false);
+async function getObjSchemaWithoutHierarchy(getSchemaFn, objType, bucketName = OBJECT_SCHEMA_BUCKET_NAME) {
+  return await getObjSchemaS3(getSchemaFn, objType, bucketName, false);
 }
 
 /**
@@ -131,8 +133,8 @@ async function getObjSchemaWithoutHierarchy(getSchemaFn, objType) {
  * @returns {Promise<Object>} The merged and validated object schema.
  * @throws {NoRetryError} If there are validation errors in the merged schema, such as duplicate storage resources or invalid field names.
  */
-async function mergeExtendObjSchema(getSchemaFn, objectSchema) {
-  let mergedObjectSchemaResult = await recursiveMergeExtendObjSchema(getSchemaFn, objectSchema);
+async function mergeExtendObjSchema(getSchemaFn, objectSchema, bucketName = OBJECT_SCHEMA_BUCKET_NAME) {
+  let mergedObjectSchemaResult = await recursiveMergeExtendObjSchema(getSchemaFn, objectSchema, bucketName);
 
   if (mergedObjectSchemaResult.errorsFound.length > 0) {
     return mergedObjectSchemaResult;
@@ -201,7 +203,7 @@ async function mergeExtendObjSchema(getSchemaFn, objectSchema) {
  * @returns {Promise<object>} - The merged object schema.
  * @throws {NoRetryError} If the recursion depth exceeds 20 or if validation fails.
  */
-async function recursiveMergeExtendObjSchema(getSchemaFn, objSchema, iter = 1) {
+async function recursiveMergeExtendObjSchema(getSchemaFn, objSchema, bucketName = OBJECT_SCHEMA_BUCKET_NAME, iter = 1) {
   if (iter > 20) {
     // throw new NoRetryError(`mergeExtendObjSchema Error objectTYpe: ${objSchema.objectType} Have more than 20 hierarchy.`)
     return {
@@ -212,8 +214,6 @@ async function recursiveMergeExtendObjSchema(getSchemaFn, objSchema, iter = 1) {
 
   objSchema = lodash.cloneDeep(objSchema);
 
-  console.log("iter in merge : ", iter);
-
   if (objSchema.hasOwnProperty("extendObjType")) {
     const extendedObjTypeValidation = validateObjType(objSchema.extendObjType);
     if (extendedObjTypeValidation.errorsFound.length > 0) {
@@ -222,7 +222,8 @@ async function recursiveMergeExtendObjSchema(getSchemaFn, objSchema, iter = 1) {
         result: null
       }
     }
-    let parentObjSchema = await getObjSchemaS3(getSchemaFn, objSchema.extendObjType, false).then(res => {
+
+    let parentObjSchema = await getObjSchemaS3(getSchemaFn, objSchema.extendObjType, bucketName, false).then(res => {
       if (res.errorsFound.length && res.errorsFound.length > 0) {
         return {
           errorsFound: res.errorsFound,
@@ -457,7 +458,7 @@ async function recursiveMergeExtendObjSchema(getSchemaFn, objSchema, iter = 1) {
         },
       };
 
-      let recursiveResult = await recursiveMergeExtendObjSchema(getSchemaFn, newObjSchema, iter);
+      let recursiveResult = await recursiveMergeExtendObjSchema(getSchemaFn, newObjSchema, bucketName, iter);
       return recursiveResult;
     }
   }
@@ -478,7 +479,7 @@ async function recursiveMergeExtendObjSchema(getSchemaFn, objSchema, iter = 1) {
  * @param {String} objType.serviceTag - The service tag associated with the object type.
  * @returns {Promise<Object>} - The reference relationship data of the specified object type, or an empty object if not found.
  */
-async function getRefObjectRelationship(getSchemaFn, objType) {
+async function getRefObjectRelationship(getSchemaFn, objType, bucketName = OBJECT_SCHEMA_BUCKET_NAME) {
   const objTypeValidation = validateObjType(objType);
   if (objTypeValidation.errorsFound.length > 0) {
     return {
@@ -492,7 +493,7 @@ async function getRefObjectRelationship(getSchemaFn, objType) {
     getParams: objType
   }
 
-  let refRelationshipData = await getSchemaFn(getDataParams);
+  let refRelationshipData = await getSchemaFn(getDataParams, bucketName);
 
   // return refRelationshipData || {};
   return {
@@ -511,7 +512,7 @@ async function getRefObjectRelationship(getSchemaFn, objType) {
  * @param {String} relType.relationshipTag - The specific relationship tag to retrieve.
  * @returns {Promise<object>} - The relationship schema data.
  */
-async function getRelationshipSchema(getSchemaFn, relType) {
+async function getRelationshipSchema(getSchemaFn, relType, bucketName = OBJECT_SCHEMA_BUCKET_NAME) {
   const relTypeValidation = validateRelType(relType);
   if (relTypeValidation.errorsFound.length > 0) {
     return {
@@ -525,7 +526,7 @@ async function getRelationshipSchema(getSchemaFn, relType) {
     getParams: relType
   }
 
-  let relationshipSchema = await getSchemaFn(getDataParams);
+  let relationshipSchema = await getSchemaFn(getDataParams, bucketName);
 
   // return relationshipSchema;
   return {
@@ -555,7 +556,8 @@ async function getObjectRelationship(
   objType,
   specificRelTags,
   overWriteBaseObjType,
-  iter = 1
+  bucketName = OBJECT_SCHEMA_BUCKET_NAME,
+  iter = 1,
 ) {
   if (iter >= 20) {
     // throw new NoRetryError(`Error:Iteration > 20 while getObjectRelationship of objType ${JSON.stringify(objType)}`);
@@ -594,7 +596,7 @@ async function getObjectRelationship(
     getParams: objType
   }
 
-  let objectRelationshipsData = await getSchemaFn(getDataParams);
+  let objectRelationshipsData = await getSchemaFn(getDataParams, bucketName);
 
   if (objectRelationshipsData && Array.isArray(objectRelationshipsData) && objectRelationshipsData.length) {
     for (const objectRel of objectRelationshipsData) {
@@ -617,7 +619,7 @@ async function getObjectRelationship(
   }
 
   // get reference relationships of objType
-  let refRelationshipsResult = await getRefObjectRelationship(getSchemaFn, objType);
+  let refRelationshipsResult = await getRefObjectRelationship(getSchemaFn, objType, bucketName);
 
   // if (refRelationshipsResult.errorsFound.length > 0) {
   //   errorsFound.push(...refRelationshipsResult.errorsFound);
@@ -644,7 +646,8 @@ async function getObjectRelationship(
         {
           serviceTag: refData.relationshipServiceTag,
           relationshipTag: relTag
-        }
+        },
+        bucketName
       );
 
       if (refRelSchemaResult.errorsFound.length > 0) {
@@ -716,7 +719,7 @@ async function getObjectRelationship(
 
     overWriteBaseObjType = overWriteBaseObjType ? overWriteBaseObjType : objType;
 
-    let extendObjectRelationshipResult = await getObjectRelationship(getSchemaFn, objSchema.extendObjType, [...specificRelTagsSet], overWriteBaseObjType, iter);
+    let extendObjectRelationshipResult = await getObjectRelationship(getSchemaFn, objSchema.extendObjType, [...specificRelTagsSet], overWriteBaseObjType, bucketName, iter);
 
     if (extendObjectRelationshipResult.errorsFound.length > 0) {
       errorsFound.push(...extendObjectRelationshipResult.errorsFound);
@@ -735,7 +738,7 @@ async function getObjectRelationship(
         // }
 
         // let linkTypeIdExtend = linkTypeIdExtendResult.result;
-        if (!linkTypeIds.has(linkTypeIdExtendResult)) { // check duplicate link arcoss child and parent
+        if (!linkTypeIds.has(linkTypeIdExtendResult)) { // check duplicate link across child and parent
           linkTypeIds.add(linkTypeIdExtendResult)
           returnRelationships.push(newExtendObject);
         }
@@ -779,6 +782,7 @@ async function getRequiredOnCreateLinks(
   getSchemaFn,
   objType,
   specificRelTags,
+  bucketName = OBJECT_SCHEMA_BUCKET_NAME
 ) {
   try {
     validateObjType(objType)
@@ -789,7 +793,7 @@ async function getRequiredOnCreateLinks(
     }
   }
 
-  let objectRelationships = await getObjectRelationship(getSchemaFn, objType, specificRelTags);
+  let objectRelationships = await getObjectRelationship(getSchemaFn, objType, specificRelTags, objType, bucketName);
 
   if (objectRelationships.errorsFound.length > 0) {
     return {
@@ -802,21 +806,16 @@ async function getRequiredOnCreateLinks(
 
   if (objectRelationships.result?.length) {
     for (const link of objectRelationships.result) {
-      if (objectRelationships.result?.length) {
-        for (const link of objectRelationships.result) {
-          if (link.base?.requiredOnCreate) {
-            returnRequiredOnCreateLinks.push(link);
-          }
-        }
-      }
-
-      // return returnRequiredOnCreateLinks;
-      return {
-        errorsFound: [],
-        result: returnRequiredOnCreateLinks
+      if (link.base?.requiredOnCreate) {
+        returnRequiredOnCreateLinks.push(link);
       }
     }
   }
+
+  return {
+    errorsFound: [],
+    result: returnRequiredOnCreateLinks
+  }
 }
 
 
@@ -840,11 +839,7 @@ async function getRequiredOnCreateLinks(
  * @returns {Promise<Object>} - A promise that resolves to the link configuration for the specified link type ID.
  * @throws {NoRetryError} - Throws an error if the direction is invalid or if the required schema data is missing.
  */
-async function getLinkConfigByLinkTypeId(getSchemaFn, firstObjType, secondObjType, relType, direction, settings = {
-  getAllLinks: false,
-  getRawLink: false,
-  getOriginalLink: false
-}) {
+async function getLinkConfigByLinkTypeId(getSchemaFn, firstObjType, secondObjType, relType, direction, settings = { getAllLinks: false, getRawLink: false, getOriginalLink: false }, bucketName = OBJECT_SCHEMA_BUCKET_NAME) {
   let errorsFound = [];
 
   if (!direction || typeof direction !== "string" || (direction !== "from" && direction !== "to")) {
@@ -880,7 +875,7 @@ async function getLinkConfigByLinkTypeId(getSchemaFn, firstObjType, secondObjTyp
     }
   }
 
-  async function getLinkTypeId(getSchemaFn, firstObjType, secondObjType, relType, direction) {
+  async function getLinkTypeId(getSchemaFn, firstObjType, secondObjType, relType, direction, bucketName) {
     const linkTypeIdResult = createLinkTypeId(firstObjType, secondObjType, relType, direction);
 
     if (linkTypeIdResult.errorsFound.length > 0) {
@@ -896,33 +891,37 @@ async function getLinkConfigByLinkTypeId(getSchemaFn, firstObjType, secondObjTyp
       }
     }
 
-    const linkConfig = await getSchemaFn(getDataParams);
+    const linkConfig = await getSchemaFn(getDataParams, bucketName);
     return linkConfig
   }
 
   let linkConfigs = [];
   if (settings.getOriginalLink) {
-    let linkConfig = await getLinkTypeId(getSchemaFn, firstObjType, secondObjType, relType, direction)
+    let linkConfig = await getLinkTypeId(getSchemaFn, firstObjType, secondObjType, relType, direction, bucketName)
     linkConfig && linkConfigs.push(linkConfig)
   } else {
-    let firstObjectTypeHie = await getObjTypeHierarchy(getSchemaFn, firstObjType);
-    let secondObjectTypeHie = await getObjTypeHierarchy(getSchemaFn, secondObjType);
-
-    if (firstObjectTypeHie.errorsFound.length > 0) {
-      errorsFound.push(...firstObjectTypeHie.errorsFound);
-      return {
-        errorsFound,
-        result: null
+    let firstObjectTypeHie = await getObjTypeHierarchy(getSchemaFn, firstObjType, [firstObjType], bucketName).then(res => {
+      if (res.errorsFound.length && res.errorsFound.length > 0) {
+        errorsFound.push(...res.errorsFound)
+        return {
+          errorsFound: res.errorsFound,
+          result: null
+        }
+      } else {
+        return res.result
       }
-    }
-
-    if (secondObjectTypeHie.errorsFound.length > 0) {
-      errorsFound.push(...secondObjectTypeHie.errorsFound);
-      return {
-        errorsFound,
-        result: null
+    });
+    let secondObjectTypeHie = await getObjTypeHierarchy(getSchemaFn, secondObjType, [secondObjType], bucketName).then(res => {
+      if (res.errorsFound.length && res.errorsFound.length > 0) {
+        errorsFound.push(...res.errorsFound)
+        return {
+          errorsFound: res.errorsFound,
+          result: null
+        }
+      } else {
+        return res.result
       }
-    }
+    });
 
     for (const firstObject of firstObjectTypeHie) {
       for (const secondObject of secondObjectTypeHie) {
@@ -982,7 +981,7 @@ async function getLinkConfig(getSchemaFn, firstObjType, secondObjType, relType,
  * @param {object} objType
  * @return {object} objectSchema
  */
-async function getObjTypeHierarchy(getSchemaFn, objType, passObjTypeHierarchy, iter = 1) {
+async function getObjTypeHierarchy(getSchemaFn, objType, passObjTypeHierarchy, bucketName = OBJECT_SCHEMA_BUCKET_NAME, iter = 1) {
   if (iter >= 20) {
     // throw NoRetryError("getObjTypeHierarchy reach limit iteration");
     return {
@@ -1008,13 +1007,23 @@ async function getObjTypeHierarchy(getSchemaFn, objType, passObjTypeHierarchy, i
     objTypeHierarchy = passObjTypeHierarchy;
   }
 
-  const objectSchema = await getObjSchemaWithoutHierarchy(getSchemaFn, objType);
+  const objectSchema = await getObjSchemaWithoutHierarchy(getSchemaFn, objType, bucketName).then(objSchema => {
+    if (objSchema.errorsFound.length) {
+      return {
+        errorsFound: objSchema.errorsFound,
+        result: null
+      }
+    } else {
+      return objSchema.result
+    }
+  });
+
 
   if (objectSchema.extendObjType) {
     iter++;
     objTypeHierarchy.push(objectSchema.extendObjType);
 
-    let extendResult = await getObjTypeHierarchy(getSchemaFn, objectSchema.extendObjType, objTypeHierarchy, iter);
+    let extendResult = await getObjTypeHierarchy(getSchemaFn, objectSchema.extendObjType, objTypeHierarchy, bucketName, iter);
 
     if (extendResult.errorsFound.length) {
       return {
@@ -1030,8 +1039,8 @@ async function getObjTypeHierarchy(getSchemaFn, objType, passObjTypeHierarchy, i
   }
 }
 
-async function getObjectSchemaForCreate(getSchemaFn, objType) {
-  let objectSchema = await getObjSchemaWithHierarchy(getSchemaFn, objType).then(objSchema => {
+async function getObjectSchemaForCreate(getSchemaFn, objType, bucketName = OBJECT_SCHEMA_BUCKET_NAME) {
+  let objectSchema = await getObjSchemaWithHierarchy(getSchemaFn, objType, bucketName).then(objSchema => {
     if (objSchema.errorsFound.length) {
       return {
         errorsFound: objSchema.errorsFound,
@@ -1044,8 +1053,8 @@ async function getObjectSchemaForCreate(getSchemaFn, objType) {
   return generateObjectSchemaForCreate(objectSchema)
 }
 
-async function getObjectSchemaForUpdate(getSchemaFn, objType) {
-  let objectSchema = await getObjSchemaWithHierarchy(getSchemaFn, objType).then(objSchema => {
+async function getObjectSchemaForUpdate(getSchemaFn, objType, bucketName = OBJECT_SCHEMA_BUCKET_NAME) {
+  let objectSchema = await getObjSchemaWithHierarchy(getSchemaFn, objType, bucketName).then(objSchema => {
     if (objSchema.errorsFound.length) {
       return {
         errorsFound: objSchema.errorsFound,
@@ -1058,8 +1067,8 @@ async function getObjectSchemaForUpdate(getSchemaFn, objType) {
   return generateObjectSchemaForUpdate(objectSchema)
 }
 
-async function getObjectSchemaCombineFieldNames(objType) {
-  let objectSchema = await getObjSchemaWithHierarchy(getSchemaFn, objType).then(objSchema => {
+async function getObjectSchemaCombineFieldNames(getSchemaFn, objType, bucketName = OBJECT_SCHEMA_BUCKET_NAME) {
+  let objectSchema = await getObjSchemaWithHierarchy(getSchemaFn, objType, bucketName).then(objSchema => {
     if (objSchema.errorsFound.length) {
       return {
         errorsFound: objSchema.errorsFound,
@@ -1071,6 +1080,39 @@ async function getObjectSchemaCombineFieldNames(objType) {
   })
   return generateObjectSchemaForCombineFieldNames(objectSchema)
 }
+
+async function getFlowSchemaS3(getSchemaFn, flowType, bucketName = OBJECT_SCHEMA_BUCKET_NAME) {
+  let errorsFound = [];
+  try {
+    validateFlowType(flowType);
+  } catch (error) {
+    errorsFound.push(error.message)
+    return {
+      errorsFound: [error.message],
+      result: null
+    }
+  }
+
+  const getDataParams = {
+    schemaName: SCHEMA_NAME.flowSchema,
+    getParams: flowType
+  }
+
+  let flowSchema = await getSchemaFn(getDataParams, bucketName);
+  if (!flowSchema) {
+    // return objSchema;
+    return {
+      errorsFound: errorsFound,
+      result: null
+    }
+  } else {
+    return {
+      errorsFound: errorsFound,
+      result: flowSchema
+    }
+  }
+}
+
 module.exports = {
   // objectSchema
   getObjSchemaS3,
@@ -1093,5 +1135,7 @@ module.exports = {
 
   getObjectSchemaForCreate,
   getObjectSchemaForUpdate,
-  getObjectSchemaCombineFieldNames
+  getObjectSchemaCombineFieldNames,
+
+  getFlowSchemaS3,
 }

package/src/libs/BasicValidatorSchema.js

@@ -689,7 +689,7 @@ const basicExtendObjectSchema = {
   }
 }
 
-// validator schema for basic realtionship schema
+// validator schema for basic relationship schema
 const relationshipBasicSchema = {
   type: "object",
   maxProperties: 1,
@@ -873,7 +873,7 @@ const relationshipBasicSchema = {
 }
 
 
-// validator schema for basic reference realtionship schema
+// validator schema for basic reference relationship schema
 const refRelationshipBasicSchema = {
   type: "object",
   required: ["objectType", "relationshipTag", "relationshipServiceTag"],
@@ -957,13 +957,101 @@ const basicFlowSchema = {
       minItems: 1,
       items: {
         type: "string",
-        enum: ["ownTopic", "extTopic", "s3", "eventBridge"],
+        enum: ["ownTopic", "extTopic", "s3", "eventBridge", "lambdaSync"],
       }
     },
     triggerType: {
       type: "string",
       enum: ["storedCache", "switch"]
     },
+    stepProperties: {
+      type: "object",
+      minProperties: 1,
+      patternProperties: {
+        [strNotEmptyRegex]: {
+          type: "object",
+          required: ["propertyName", "type"],
+          properties: {
+            propertyName: {
+              type: "string"
+            },
+            type: {
+              type: "string"
+            },
+            objectField: {
+              type: "object",
+              required: ["objType", "fieldName"],
+              properties: {
+                objType: {
+                  type: "object",
+                  required: ["objectType", "serviceTag"],
+                  properties: {
+                    objectType: {
+                      type: "string",
+                      pattern: strNotEmptyRegex
+                    },
+                    serviceTag: {
+                      type: "string",
+                      pattern: strNotEmptyRegex
+                    }
+                  }
+                },
+                fieldName: {
+                  type: "string"
+                }
+              }
+            },
+            overwritePropertyName: {
+              type: "string"
+            }
+          }
+        }
+      }
+    },
+    stepMessageAttributes: {
+      type: "object",
+      minProperties: 1,
+      patternProperties: {
+        [strNotEmptyRegex]: {
+          type: "object",
+          required: ["propertyName", "type"],
+          properties: {
+            propertyName: {
+              type: "string"
+            },
+            type: {
+              type: "string"
+            },
+            objectField: {
+              type: "object",
+              required: ["objType", "fieldName"],
+              properties: {
+                objType: {
+                  type: "object",
+                  required: ["objectType", "serviceTag"],
+                  properties: {
+                    objectType: {
+                      type: "string",
+                      pattern: strNotEmptyRegex
+                    },
+                    serviceTag: {
+                      type: "string",
+                      pattern: strNotEmptyRegex
+                    }
+                  }
+                },
+                fieldName: {
+                  type: "string"
+                }
+              }
+            },
+            overwritePropertyName: {
+              type: "string"
+            }
+          }
+        }
+      }
+    },
     flowSteps: {
       type: "object",
       minProperties: 1, // incase outputTopic === false
@@ -973,12 +1061,18 @@ const basicFlowSchema = {
           required: ["properties", "messageAttributes"],
           properties: {
             properties: {
-              minProperties: 1,
-              type: "object",
+              type: "array",
+              items: {
+                type: "string"
+              },
+              // minItems: 1
             },
             messageAttributes: {
-              minProperties: 1,
-              type: "object"
+              type: "array",
+              items: {
+                type: "string"
+              },
+              // minItems: 1
             }
           }
         }
@@ -994,6 +1088,9 @@ const basicFlowSchema = {
     },
     outputTopic: {
       type: "boolean"
+    },
+    externalEndpoint: {
+      type: "boolean"
     }
   }
 }

package/src/libs/ReformatObjectSchema.js

@@ -178,6 +178,7 @@ function generateObjectSchemaForUpdate(objSchema) {
  * @returns {Object}            - objectSchema that has property for case update
  */
 function generateObjectSchemaForCombineFieldNames(objSchema) {
+  console.log("generateObjectSchemaForCombineFieldNames", objSchema)
   // generate data for case update
   let initReturnObj = {
     objectType: objSchema.objectType,

package/src/libs/RelSchemaLib.js

@@ -22,6 +22,7 @@ const lodash = require("lodash");
 
 const getObjectSchema = require("../GetObjectSchema");
 const { validateObjType } = require("./ValidateObjType");
+const { OBJECT_SCHEMA_BUCKET_NAME } = require("../Consts");
 
 /**
  * Recursively creates an object type hierarchy by traversing through the schema
@@ -36,7 +37,7 @@ const { validateObjType } = require("./ValidateObjType");
  * @returns {Promise<string[]>} A promise that resolves to an array representing the object type hierarchy.
  * @throws {NoRetryError} Throws an error if the maximum iteration limit (20) is reached.
  */
-async function createObjTypeHierarchy(getSchemaFn, objType, passObjTypeHierarchy, iter = 1) {
+async function createObjTypeHierarchy(getSchemaFn, objType, passObjTypeHierarchy, bucketName = OBJECT_SCHEMA_BUCKET_NAME, iter = 1) {
   if (iter >= 20) {
     // throw NoRetryError("createObjTypeHierarchy reach limit iteration");
     return {
@@ -62,7 +63,7 @@ async function createObjTypeHierarchy(getSchemaFn, objType, passObjTypeHierarchy
     objTypeHierarchy = passObjTypeHierarchy;
   }
 
-  const objectSchemaResult = await getObjectSchema.getObjSchemaWithoutHierarchy(getSchemaFn, objType);
+  const objectSchemaResult = await getObjectSchema.getObjSchemaWithoutHierarchy(getSchemaFn, objType, bucketName);
 
 
   if (objectSchemaResult.errorFounds.length > 0) {
@@ -78,7 +79,7 @@ async function createObjTypeHierarchy(getSchemaFn, objType, passObjTypeHierarchy
     iter++;
     objTypeHierarchy.push(objectSchema.extendObjType);
 
-    let extendResult = await createObjTypeHierarchy(getSchemaFn, objectSchema.extendObjType, objTypeHierarchy, iter);
+    let extendResult = await createObjTypeHierarchy(getSchemaFn, objectSchema.extendObjType, [objTypeHierarchy], bucketName, iter);
 
     if (extendResult.errorFounds.length > 0) {
       return {
@@ -108,7 +109,7 @@ async function createObjTypeHierarchy(getSchemaFn, objType, passObjTypeHierarchy
  * @returns {Promise<object[]>} A promise that resolves to an array of refactored links matching the object types.
  * @throws {NoRetryError} Throws an error if the input parameters are invalid.
  */
-async function findLinksByObjTypes(getSchemaFn, objTypes, relationshipLinks) {
+async function findLinksByObjTypes(getSchemaFn, objTypes, relationshipLinks, bucketName = OBJECT_SCHEMA_BUCKET_NAME) {
 
   if (!Array.isArray(relationshipLinks)) {
     return {
@@ -144,8 +145,8 @@ async function findLinksByObjTypes(getSchemaFn, objTypes, relationshipLinks) {
   const secondObjType = objTypes[1];
 
   // first create hierarchy of each objType
-  const firstObjTypeTree = await createObjTypeHierarchy(getSchemaFn, objTypes[0]);
-  const secondObjTypeTree = await createObjTypeHierarchy(getSchemaFn, objTypes[1]);
+  const firstObjTypeTree = await createObjTypeHierarchy(getSchemaFn, objTypes[0], [objTypes[0]], bucketName);
+  const secondObjTypeTree = await createObjTypeHierarchy(getSchemaFn, objTypes[1], [objTypes[1]], bucketName);
 
   if (firstObjTypeTree.errorFounds.length > 0) {
     return {