@izara_project/izara-core-library-service-schemas 1.0.71 → 1.0.73

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izara_project/izara-core-library-service-schemas",
-  "version": "1.0.71",
+  "version": "1.0.73",
   "description": "Schemas for the service and objects it controls",
   "main": "index.js",
   "scripts": {
@@ -14,22 +14,23 @@
   "license": "AGPL-3.0-or-later",
   "homepage": "https://bitbucket.org/izara-core-libraries/izara-core-library-service-schemas/src/master/README.md",
   "devDependencies": {
-    "jest": "^29.7.0"
+    "jest": "^30.0.2"
   },
   "jest": {
     "testEnvironment": "node"
   },
   "dependencies": {
-    "@aws-sdk/client-lambda": "^3.787.0",
-    "@aws-sdk/client-s3": "^3.787.0",
-    "@aws-sdk/crc64-nvme-crt": "^3.787.0",
+    "@aws-sdk/client-lambda": "^3.835.0",
+    "@aws-sdk/client-s3": "^3.835.0",
+    "@aws-sdk/crc64-nvme-crt": "^3.835.0",
+    "@aws-sdk/client-api-gateway": "^3.835.0",
     "@izara_project/izara-core-library-core": "^1.0.19",
     "@izara_project/izara-core-library-external-request": "^1.0.20",
     "@izara_project/izara-core-library-lambda": "^1.0.4",
     "@izara_project/izara-core-library-logger": "^1.0.7",
     "@izara_project/izara-shared-core": "^1.0.2",
-    "@izara_project/izara-shared-service-schemas": "^1.0.16",
-    "glob": "^11.0.2",
+    "@izara_project/izara-shared-service-schemas": "^1.0.19",
+    "glob": "^11.0.3",
     "lodash": "^4.17.21",
     "object-hash": "^3.0.0",
     "read-yaml-file": "^2.1.0"

package/src/Consts.js

@@ -106,84 +106,109 @@ const PREFIX_PATH_S3 = {
 // ---------   Upload path ---------------
 
 function relationshipTagPathS3(_izContext, relType) {
-  validateRelType(relType);
+  const validateRelTypeResult = validateRelType(relType);
+  if (validateRelTypeResult.errorsFound.length > 0) {
+    throw new NoRetryError(`function relationshipTagPathS3: invalid relType ${relType.name} - ${validateRelTypeResult.errorsFound.join(", ")}`);
+  }
   return `${PREFIX_PATH_S3.perServiceSchemas}/${relType.serviceTag}/Relationships/RelationshipTags/${relType.relationshipTag}.json`
 }
 
 function objectRelationshipPathS3(_izContext, objType) {
-  validateObjType(objType);
+  const validateObjTypeResult = validateObjType(objType);
+  if (validateObjTypeResult.errorsFound.length > 0) {
+    throw new NoRetryError(`function objectRelationshipPathS3: invalid objType ${objType.name} - ${validateObjTypeResult.errorsFound.join(", ")}`);
+  }
   return `${PREFIX_PATH_S3.perServiceSchemas}/${objType.serviceTag}/Relationships/ObjectRelationships/${objType.objectType}.json`
 }
 
 function linkByLinkTypeIdPathS3(_izContext, serviceTag, linkTypeId) {
   if (!serviceTag || !linkTypeId || typeof (serviceTag) !== "string" || typeof (linkTypeId) !== "string") {
-    throw new NoRetryError("invalid serviceTag or linkTypeId")
+    // throw new NoRetryError("invalid serviceTag or linkTypeId")
+    throw new NoRetryError("invalid serviceTag or linkTypeId");
   }
-  return `${PREFIX_PATH_S3.perServiceSchemas}/${serviceTag}/Relationships/LinkByLinkTypeId/${linkTypeId}.json`
+  return `${PREFIX_PATH_S3.perServiceSchemas}/${serviceTag}/Relationships/LinkByLinkTypeId/${linkTypeId}.json`;
 }
 
 
 function refObjectRelationshipPathS3(_izContext, objType) {
-  validateObjType(objType);
-  return `${PREFIX_PATH_S3.perServiceSchemas}/${objType.serviceTag}/Relationships/RefObjectRelationships/${objType.objectType}.json`
+  const validateObjTypeResult = validateObjType(objType);
+  if (validateObjTypeResult.errorsFound.length > 0) {
+    throw new NoRetryError(`function refObjectRelationshipPathS3: invalid objType ${objType.name} - ${validateObjTypeResult.errorsFound.join(", ")}`);
+  }
+  return `${PREFIX_PATH_S3.perServiceSchemas}/${objType.serviceTag}/Relationships/RefObjectRelationships/${objType.objectType}.json`;
 }
 
 function objectSchemaAllPathS3(_izContext, objType) {
-  validateObjType(objType);
-  return `${PREFIX_PATH_S3.perServiceSchemas}/${objType.serviceTag}/ObjectSchemaAll/${objType.objectType}.json`
+  const validateObjTypeResult = validateObjType(objType);
+  if (validateObjTypeResult.errorsFound.length > 0) {
+    throw new NoRetryError(`function objectSchemaAllPathS3: invalid objType ${objType.name} - ${validateObjTypeResult.errorsFound.join(", ")}`);
+  }
+  return `${PREFIX_PATH_S3.perServiceSchemas}/${objType.serviceTag}/ObjectSchemaAll/${objType.objectType}.json`;
 }
 
 function objectSchemaCreatePathS3(_izContext, objType) {
-  validateObjType(objType);
-  return `${PREFIX_PATH_S3.perServiceSchemas}/${objType.serviceTag}/ObjectSchemaCreate/${objType.objectType}.json`
+  const validateObjTypeResult = validateObjType(objType);
+  if (validateObjTypeResult.errorsFound.length > 0) {
+    throw new NoRetryError(`function objectSchemaCreatePathS3: invalid objType ${objType.name} - ${validateObjTypeResult.errorsFound.join(", ")}`);
+  }
+  return `${PREFIX_PATH_S3.perServiceSchemas}/${objType.serviceTag}/ObjectSchemaCreate/${objType.objectType}.json`;
 }
 
 function objectSchemaDisplayPathS3(_izContext, objType) {
-  validateObjType(objType);
-  return `${PREFIX_PATH_S3.perServiceSchemas}/${objType.serviceTag}/ObjectSchemaDisplay/${objType.objectType}.json`
+  const validateObjTypeResult = validateObjType(objType);
+  if (validateObjTypeResult.errorsFound.length > 0) {
+    throw new NoRetryError(`function objectSchemaDisplayPathS3: invalid objType ${objType.name} - ${validateObjTypeResult.errorsFound.join(", ")}`);
+  }
+  return `${PREFIX_PATH_S3.perServiceSchemas}/${objType.serviceTag}/ObjectSchemaDisplay/${objType.objectType}.json`;
 }
 
 function objectSchemaCombineFieldNamesPathS3(_izContext, objType) {
-  validateObjType(objType);
-  return `${PREFIX_PATH_S3.perServiceSchemas}/${objType.serviceTag}/ObjectSchemaCombineFieldNames/${objType.objectType}.json`
+  const validateObjTypeResult = validateObjType(objType);
+  if (validateObjTypeResult.errorsFound.length > 0) {
+    throw new NoRetryError(`function objectSchemaCombineFieldNamesPathS3: invalid objType ${objType.name} - ${validateObjTypeResult.errorsFound.join(", ")}`);
+  }
+  return `${PREFIX_PATH_S3.perServiceSchemas}/${objType.serviceTag}/ObjectSchemaCombineFieldNames/${objType.objectType}.json`;
 }
 
 function objectListAllPathS3(_izContext, serviceTag) {
   if (!serviceTag || typeof (serviceTag) !== "string") {
-    throw new NoRetryError("invalid serviceTag.")
+    throw new NoRetryError("invalid serviceTag.");
   }
-  return `${PREFIX_PATH_S3.perServiceSchemas}/${serviceTag}/ObjectListAll.json`
+  return `${PREFIX_PATH_S3.perServiceSchemas}/${serviceTag}/ObjectListAll.json`;
 }
 
 function objectListCreatePathS3(_izContext, serviceTag) {
   if (!serviceTag || typeof (serviceTag) !== "string") {
-    throw new NoRetryError("invalid serviceTag.")
+    throw new NoRetryError("invalid serviceTag.");
   }
-  return `${PREFIX_PATH_S3.perServiceSchemas}/${serviceTag}/ObjectListCreate.json`
+  return `${PREFIX_PATH_S3.perServiceSchemas}/${serviceTag}/ObjectListCreate.json`;
 }
 
 function lambdaFunctionsPathS3(_izContext, serviceTag) {
   if (!serviceTag || typeof (serviceTag) !== "string") {
-    throw new NoRetryError("invalid serviceTag.")
+    throw new NoRetryError("invalid serviceTag.");
   }
-  return `${PREFIX_PATH_S3.perServiceSchemas}/${serviceTag}/LambdaFunctions.json`
+  return `${PREFIX_PATH_S3.perServiceSchemas}/${serviceTag}/LambdaFunctions.json`;
 }
 
 function serviceNamePathS3(_izContext, serviceTag) {
   if (!serviceTag || typeof (serviceTag) !== "string") {
-    throw new NoRetryError("invalid serviceTag.")
+    throw new NoRetryError("invalid serviceTag.");
   }
-  return `${PREFIX_PATH_S3.perServiceSchemas}/${serviceTag}/ServiceName.json`
+  return `${PREFIX_PATH_S3.perServiceSchemas}/${serviceTag}/ServiceName.json`;
 }
 
 function flowSchemaPathS3(_izContext, flowType) {
-  validateFlowType(flowType);
-  return `${PREFIX_PATH_S3.perServiceSchemas}/${flowType.serviceTag}/FlowSchema/${flowType.flowTag}.json`
+  const validateFlowTypeResult = validateFlowType(flowType);
+  if (validateFlowTypeResult.errorsFound.length > 0) {
+    throw new NoRetryError(`function flowSchemaPathS3: invalid flowType ${flowType.name} - ${validateFlowTypeResult.errorsFound.join(", ")}`);
+  }
+  return `${PREFIX_PATH_S3.perServiceSchemas}/${flowType.serviceTag}/FlowSchema/${flowType.flowTag}.json`;
 }
 
 function coreFunctionNames(_izContext, prefix, stage) {
   if (!prefix || typeof (prefix) !== "string" && !stage || typeof (stage) !== "string") {
-    throw new NoRetryError("invalid serviceTag or stage.")
+    throw new NoRetryError("invalid serviceTag or stage.");
   }
   const coreFunctionNames = [
     `${prefix}${stage}InitialSetup`,
@@ -272,7 +297,22 @@ function createValidationFieldNameForEachType(type, validation) {
   }[type]
 }
 
-const S3_UPLOAD_TYPE = ["image", "video", "csv", 'yaml']
+function flowSchemaPathS3(_izContext, flowType) {
+  validateFlowType(flowType);
+  return `${PREFIX_PATH_S3.perServiceSchemas}/${flowType.serviceTag}/FlowSchema/${flowType.flowTag}.json`
+}
+
+function getEndpointPerObjectType(_izContext, objType) {
+  validateObjType(objType);
+  return `${PREFIX_PATH_S3.perServiceSchemas}/${objType.serviceTag}/FrontEnd/Endpoint/Endpoint_Get_${objType.objectType}.json`
+}
+
+function getEndpointPerService(serviceTag) {
+  if (typeof serviceTag !== "string" || !serviceTag) {
+    throw new NoRetryError("invalid serviceTag.")
+  }
+  return `${PREFIX_PATH_S3.perServiceSchemas}/${serviceTag}/FrontEnd/Endpoint/Endpoint_Get.json`
+}
 
 const UPLOAD_PATH_S3 = {
   relationshipTag: relationshipTagPathS3,
@@ -294,19 +334,9 @@ const UPLOAD_PATH_S3 = {
 
   lambdaFunctions: lambdaFunctionsPathS3,
   serviceName: serviceNamePathS3,
-  coreFunctionNames: coreFunctionNames
-}
-
-const FLOW_SCHEMA_HOOK_STATE = {
-  beforeCreate: "before:Create",
-  afterCreate: "after:Create",
-  beforeCheckLimit: "before:CheckLimit",
-  afterCheckLimit: "after:CheckLimit",
-  beforeCreatePreSignedUrl: "before:CreatePreSignedUrl",
-  afterCreatePreSignedUrl: "after:CreatePreSignedUrl",
-  afterUploadS3: "after:UploadS3",
-  beforeProcessCalculate: "before:ProcessCalculate",
-  afterProcessCalculate: "after:ProcessCalculate"
+  coreFunctionNames: coreFunctionNames,
+  getEndpointPerObjectType: getEndpointPerObjectType,
+  getEndpointPerService: getEndpointPerService
 }
 
 // --------- End Upload path ---------------
@@ -337,6 +367,4 @@ module.exports = {
 
   LOCAL_FILENAME: LOCAL_FILENAME,
   createValidationFieldNameForEachType,
-  S3_UPLOAD_TYPE,
-  FLOW_SCHEMA_HOOK_STATE
 }

package/src/GetObjectSchema.js

@@ -30,7 +30,7 @@ const {
   getObjSchemaWithHierarchy,
   getObjSchemaWithoutHierarchy,
   mergeExtendObjSchema: mergeExtendObjSchemaShared,
-  recursiveMergeExtendObjSchema: recursiveMergeExtendObjSchemaShared,
+  // recursiveMergeExtendObjSchema: recursiveMergeExtendObjSchemaShared,
   getRefObjectRelationship: getRefObjectRelationshipShared,
   getRelationshipSchema: getRelationshipSchemaShared,
   getObjectRelationship: getObjectRelationshipShared,
@@ -38,7 +38,7 @@ const {
   getLinkConfigByLinkTypeId: getLinkConfigByLinkTypeIdShared,
   getObjTypeHierarchy: getObjTypeHierarchyShared
 } = sharedServiceSchema.getObjectSchema;
-const { validateObjType, validateRelType, validateFlowType } = sharedServiceSchema.validateObjType;
+const { validateObjType, validateFlowType } = sharedServiceSchema.validateObjType;
 const {
   basicFieldNameSchema,
   basicFieldNameSchemaForCombineFieldName
@@ -165,9 +165,11 @@ function getDataFromPath(
  * @returns {Promise<object>}                                  Return object schema of objectTypes
  */
 async function getLocalObjectSchemas(_izContext, objectTypes, objSchemaPath = LOCAL_OBJECT_SCHEMA_PATH, getExtendObType = false) {
+  let errorsFound = [];
   // validate objectTypes
   if (!objectTypes) {
-    throw new NoRetryError("required objectTypes");
+    // throw new NoRetryError("required objectTypes");
+    errorsFound.push("getLocalObjectSchemas: Parameter 'objectTypes' is required but was not provided.");
   }
 
   if (typeof (objectTypes) === "string") {
@@ -175,11 +177,20 @@ async function getLocalObjectSchemas(_izContext, objectTypes, objSchemaPath = LO
   }
 
   if (!Array.isArray(objectTypes)) {
-    throw new NoRetryError(`Unhandled objectTypes param: ${objectTypes}`);
+    // throw new NoRetryError(`Unhandled objectTypes param: ${objectTypes}`);
+    errorsFound.push(`getLocalObjectSchemas: Parameter 'objectTypes' must be an array, received: ${typeof objectTypes}`);
   }
 
   if (!objectTypes.length) {
-    throw new NoRetryError(`ObjectTypes cannot empty`);
+    // throw new NoRetryError(`ObjectTypes cannot empty`);
+    errorsFound.push(`getLocalObjectSchemas: Parameter 'objectTypes' cannot be an empty array.`);
+  }
+
+  if (errorsFound.length > 0) {
+    return {
+      errorsFound: errorsFound,
+      result: null
+    }
   }
 
 
@@ -199,7 +210,7 @@ async function getLocalObjectSchemas(_izContext, objectTypes, objSchemaPath = LO
     // returnValue.fieldLookup[objectType] = null;
   }
 
-  const allObjectSchemas = lodash.cloneDeep(getDataFromPath(_izContext, LOCAL_FILENAME.OBJECT_SCHEMA, objSchemaPath)
+  let allObjectSchemas = lodash.cloneDeep(getDataFromPath(_izContext, LOCAL_FILENAME.OBJECT_SCHEMA, objSchemaPath)
     .flat()
     .filter(schema => filteredObjectTypes.includes(schema.objectType))
   );
@@ -209,7 +220,12 @@ async function getLocalObjectSchemas(_izContext, objectTypes, objSchemaPath = LO
   if (getExtendObType) {
     await Promise.all(
       allObjectSchemas.map(async (objSchema, idx) => {
-        allObjectSchemas[idx] = await mergeExtendObjSchema(_izContext, objSchema);
+        const mergeResult = await mergeExtendObjSchema(_izContext, objSchema)
+        if (mergeResult?.errorsFound?.length && mergeResult?.errorsFound?.length > 0) {
+          throw new NoRetryError(mergeResult.errorsFound)
+        } else {
+          allObjectSchemas[idx] = mergeResult;
+        }
       })
     )
   }
@@ -230,10 +246,10 @@ async function getLocalObjectSchemas(_izContext, objectTypes, objSchemaPath = LO
       throw new NoRetryError(`Found duplicate shortNameObjectType: '${objSchema.shortNameObjectType}' in file ObjectFieldSchema.js `);
     }
   }
-
   returnValue.records = allObjectSchemas;
 
-  return returnValue;
+  return returnValue
+
 }
 
 
@@ -281,7 +297,6 @@ async function getAllLocalObjectSchemas(_izContext, objSchemaPath = LOCAL_OBJECT
     // .filter(schema => objectTypeList.includes(schema.objectType))
   );
 
-
   // check objectType that not found in ObjectFieldSchema.js
   // const remainingObjectTypes = objectTypeList.filter(objectType => !allObjectSchemas.some(schema => schema.objectType === objectType));
 
@@ -296,17 +311,22 @@ async function getAllLocalObjectSchemas(_izContext, objSchemaPath = LOCAL_OBJECT
   if (getExtendObType) {
     await Promise.all(
       allObjectSchemas.map(async (objSchema, idx) => {
-        allObjectSchemas[idx] = await mergeExtendObjSchema(_izContext, objSchema)
+        const mergeResult = await mergeExtendObjSchema(_izContext, objSchema)
+
+        allObjectSchemas[idx] = mergeResult;
       })
     )
   }
-
   // add objectSchema to returnValue object
   for (let [idx, objSchema] of allObjectSchemas.entries()) {
     if (!returnValue.fieldLookup.hasOwnProperty(objSchema.objectType)) {
       returnValue.fieldLookup[objSchema.objectType] = idx;
     } else {
-      throw new NoRetryError(`Found duplicate objectType: '${objSchema.objectType}' in file ObjectFieldSchema.js`);
+      // throw new NoRetryError(`Found duplicate objectType: '${objSchema.objectType}' in file ObjectFieldSchema.js`);
+      return {
+        errorsFound: [`getAllLocalObjectSchemas: Found duplicate objectType: '${objSchema.objectType}' in file ObjectFieldSchema.js`],
+        result: null
+      };
     }
     if (objSchema?.shortNameObjectType) {
       if (!returnValue.shortNameObjectTypeLookup.hasOwnProperty(objSchema.shortNameObjectType)) {
@@ -320,8 +340,7 @@ async function getAllLocalObjectSchemas(_izContext, objSchemaPath = LOCAL_OBJECT
 
   returnValue.records = allObjectSchemas;
 
-  return returnValue;
-
+  return returnValue
 }
 
 /**
@@ -450,7 +469,13 @@ async function getObjSchemaS3(
   objType,
   getExtendObType = false
 ) {
-  return await getObjectSchemaS3Shared(getSchemaByNameWithCache, objType, getExtendObType);
+  return await getObjectSchemaS3Shared(getSchemaByNameWithCache, objType, getExtendObType).then(res => {
+    if (res.errorsFound.length && res.errorsFound.length > 0) {
+      throw new NoRetryError(res.errorsFound)
+    } else {
+      return res.result
+    }
+  });
 }
 
 
@@ -478,7 +503,13 @@ const getObjSchemaS3WithCache = inMemoryCacheLib(
  */
 async function getObjSchemaS3WithHierarchy(_izContext, objType) {
   // return await getObjSchemaS3WithCache(_izContext, objType, true)
-  return await getObjSchemaWithHierarchy(getSchemaByNameWithCache, objType)
+  return await getObjSchemaWithHierarchy(getSchemaByNameWithCache, objType).then(res => {
+    if (res.errorsFound.length && res.errorsFound.length > 0) {
+      throw new NoRetryError(res.errorsFound)
+    } else {
+      return res.result
+    }
+  });
 }
 
 /**
@@ -489,7 +520,13 @@ async function getObjSchemaS3WithHierarchy(_izContext, objType) {
  */
 async function getObjSchemaS3WithoutHierarchy(_izContext, objType) {
   // return await getObjSchemaS3WithCache(_izContext, objType, false)
-  return await getObjSchemaWithoutHierarchy(getSchemaByNameWithCache, objType)
+  return await getObjSchemaWithoutHierarchy(getSchemaByNameWithCache, objType).then(res => {
+    if (res.errorsFound.length && res.errorsFound.length > 0) {
+      throw new NoRetryError(res.errorsFound)
+    } else {
+      return res.result
+    }
+  });
 }
 
 
@@ -505,7 +542,11 @@ async function getObjSchemaS3WithoutHierarchy(_izContext, objType) {
 async function getObjectSchemaCombineFieldNames(_izContext, objType) {
 
   const objSchema = await getObjSchemaS3WithHierarchy(_izContext, objType);
-  return generateObjectSchemaForCombineFieldNames(_izContext, objSchema);
+  if (objSchema.errorsFound.length > 0) {
+    throw new NoRetryError(`getObjectSchemaCombineFieldNames: ${objSchema.errorsFound.join(', ')}`);
+  }
+  const combinedSchema = generateObjectSchemaForCombineFieldNames(_izContext, objSchema.result);
+  return combinedSchema
 }
 
 /**
@@ -599,7 +640,13 @@ function getLocalRelationshipSchemas(_izContext, relationshipTags, objSchemaPath
  * @returns {Promise<Object>}                 - reference relationship schema of objType
  */
 async function getRefObjectRelationship(_izContext, objType) {
-  return await getRefObjectRelationshipShared(getSchemaByNameWithCache, objType)
+  return await getRefObjectRelationshipShared(getSchemaByNameWithCache, objType).then(res => {
+    if (res.errorsFound.length && res.errorsFound.length > 0) {
+      throw new NoRetryError(res.errorsFound)
+    } else {
+      return res.result
+    }
+  })
 }
 
 /**
@@ -628,8 +675,13 @@ const getRefObjectRelationshipWithCache = inMemoryCacheLib(
  *
  */
 async function getRelationshipSchema(_izContext, relType) {
-
-  return await getRelationshipSchemaShared(getSchemaByNameWithCache, relType)
+  return await getRelationshipSchemaShared(getSchemaByNameWithCache, relType).then(res => {
+    if (res.errorsFound.length && res.errorsFound.length > 0) {
+      throw new NoRetryError(res.errorsFound)
+    } else {
+      return res.result
+    }
+  })
 }
 
 
@@ -666,7 +718,11 @@ async function getRelationshipServiceTag(_izContext, relationshipTag, objType) {
     objType,
   });
 
-  validateObjType(objType);
+  const validateObjTypeResult = validateObjType(objType);
+  if (validateObjTypeResult.errorsFound.length > 0) {
+    _izContext.logger.error("getRelationshipServiceTag: Invalid objType: ", validateObjTypeResult.errorsFound);
+    throw new NoRetryError(`getRelationshipServiceTag: Invalid objType: ${JSON.stringify(objType)}, ${validateObjTypeResult.errorsFound.join(", ")}`);
+  }
 
   const relTagPath = UPLOAD_PATH_S3.relationshipTag(
     _izContext,
@@ -684,8 +740,9 @@ async function getRelationshipServiceTag(_izContext, relationshipTag, objType) {
   if (relSchemaHeadData) {
     return objType.serviceTag;
   } else {
-    const refObjRel = await getRefObjectRelationship(_izContext, objType);
-
+    // const refObjRel = await getRefObjectRelationship(_izContext, objType);
+    const getRefObjRelWithCacheResult = await getRefObjectRelationshipWithCache(_izContext, objType);
+    const refObjRel = getRefObjRelWithCacheResult.records;
     if (refObjRel.hasOwnProperty(relationshipTag)) {
       return refObjRel[relationshipTag].relationshipServiceTag
     } else {
@@ -715,7 +772,7 @@ const getRelationshipServiceTagWithCache = inMemoryCacheLib(
 
 /**
  *
- * get realtionshipSchema of objType depend on specific relationshipTags
+ * get relationshipSchema of objType depend on specific relationshipTags
  *
  * @param {Object} _izContext
  * @param {Object} objType
@@ -731,7 +788,13 @@ async function getObjectRelationship(
   overWriteBaseObjType,
 ) {
 
-  return await getObjectRelationshipShared(getSchemaByNameWithCache, objType, specificRelTags, overWriteBaseObjType)
+  return await getObjectRelationshipShared(getSchemaByNameWithCache, objType, specificRelTags, overWriteBaseObjType).then(res => {
+    if (res.errorsFound.length && res.errorsFound.length > 0) {
+      throw new NoRetryError(res.errorsFound)
+    } else {
+      return res.result
+    }
+  })
 }
 
 
@@ -775,7 +838,13 @@ async function getRequiredOnCreateLinks(
     specificRelTags,
   });
 
-  return await getRequiredOnCreateLinksShared(getSchemaByNameWithCache, objType, specificRelTags)
+  return await getRequiredOnCreateLinksShared(getSchemaByNameWithCache, objType, specificRelTags).then(res => {
+    if (res.errorsFound.length && res.errorsFound.length > 0) {
+      throw new NoRetryError(res.errorsFound)
+    } else {
+      return res.result
+    }
+  })
 }
 
 
@@ -851,7 +920,13 @@ async function getLinkConfigByLinkTypeId(_izContext, firstObjType, secondObjType
     settings
   });
 
-  return await getLinkConfigByLinkTypeIdShared(getSchemaByNameWithCache, firstObjType, secondObjType, relType, direction, settings);
+  await getLinkConfigByLinkTypeIdShared(getSchemaByNameWithCache, firstObjType, secondObjType, relType, direction, settings).then(res => {
+    if (res.errorsFound.length && res.errorsFound.length > 0) {
+      throw new NoRetryError(res.errorsFound)
+    } else {
+      return res.result
+    }
+  });
 }
 
 /**
@@ -882,8 +957,14 @@ const getLinkConfigByLinkTypeIdWithCache = inMemoryCacheLib(
  * @returns
  */
 async function mergeExtendObjSchema(_izContext, objectSchema) {
-  // return mergedObjectSchema;
-  return await mergeExtendObjSchemaShared(getSchemaByNameWithCache, objectSchema);
+  let mergedObjectSchema = await mergeExtendObjSchemaShared(getSchemaByNameWithCache, objectSchema).then(res => {
+    if (res.errorsFound.length && res.errorsFound.length > 0) {
+      throw new NoRetryError(`objectSchema.objectType: ${objectSchema.objectType} ${res.errorsFound}`)
+    } else {
+      return res.result
+    }
+  });
+  return mergedObjectSchema
 }
 
 
@@ -966,7 +1047,11 @@ async function getFlowSchemaS3(
   _izContext,
   flowType,
 ) {
-  validateFlowType(flowType);
+  const validateFlowTypeResult = validateFlowType(flowType);
+  if (validateFlowTypeResult.errorsFound.length > 0) {
+    _izContext.logger.error("getFlowSchemaS3: Invalid flowType: ", validateFlowTypeResult.errorsFound);
+    throw new NoRetryError(`getFlowSchemaS3: Invalid flowType: ${JSON.stringify(flowType)}, ${validateFlowTypeResult.errorsFound.join(", ")}`);
+  }
 
   const getObjSchemaParam = {
     Bucket: OBJECT_SCHEMA_BUCKET_NAME,

package/src/IdentifiersObject.js

@@ -59,7 +59,12 @@ function checkStorageTypeOfObjectSchemaIdentifiers(_izContext, objectSchema) {
  * @returns {Promise<Object>}        - identifiersObject
  */
 async function identifiersFromObjInstanceBase(_izContext, objType, objInstanceBase) {
-  validateObjType(objType);
+  const validateObjTypeResult = validateObjType(objType);
+  if (validateObjTypeResult.errorsFound.length > 0) {
+    _izContext.logger.error("identifiersObjectFromBaseObjInstance: Invalid objType: ", validateObjTypeResult.errorsFound);
+    throw new NoRetryError(`identifiersObjectFromBaseObjInstance: Invalid objType: ${validateObjTypeResult.errorsFound.join(', ')}`);
+  }
+
   _izContext.logger.debug("identifiersObjectFromBaseObjInstance: ", { objType, baseObjInstance: objInstanceBase });
 
   const objSchema = await getSchema.getObjSchemaS3WithHierarchy(_izContext, objType);
@@ -140,7 +145,12 @@ async function identifiersFromObjInstanceBase(_izContext, objType, objInstanceBa
  * @returns {Promise<Object>}         - concatIdentifiersObject
  */
 async function identifiersBaseFromIdentifiers(_izContext, objType, identifiers) {
-  validateObjType(objType);
+  const validateObjTypeResult = validateObjType(objType);
+  if (validateObjTypeResult.errorsFound.length > 0) {
+    _izContext.logger.error("identifiersBaseFromIdentifiers: Invalid objType: ", validateObjTypeResult.errorsFound);
+    throw new NoRetryError(`identifiersBaseFromIdentifiers: Invalid objType: ${JSON.stringify(objType)}, ${validateObjTypeResult.errorsFound.join(", ")}`);
+  }
+
   _izContext.logger.debug("concatIdentifiersFromIdentifiersObject: ", { objType, identifiersObject: identifiers });
 
   const objSchema = await getSchema.getObjSchemaS3WithHierarchy(_izContext, objType);
@@ -191,7 +201,11 @@ async function identifiersBaseFromIdentifiers(_izContext, objType, identifiers)
  * @returns {Promise<Object>}         - refactoredObjInstance
  */
 async function objInstanceFromobjInstanceBase(_izContext, objType, objInstance) {
-  validateObjType(objType)
+  const validateObjTypeResult = validateObjType(objType);
+  if (validateObjTypeResult.errorsFound.length > 0) {
+    _izContext.logger.error("objInstanceFromobjInstanceBase: Invalid objType: ", validateObjTypeResult.errorsFound);
+    throw new NoRetryError(`objInstanceFromobjInstanceBase: Invalid objType: ${JSON.stringify(objType)}, ${validateObjTypeResult.errorsFound.join(", ")}`);
+  }
 
   const objSchema = await getSchema.getObjSchemaS3WithHierarchy(_izContext, objType);
 
@@ -222,7 +236,12 @@ async function objInstanceFromobjInstanceBase(_izContext, objType, objInstance)
  * @returns {Promise<String>}           - compositeIdentifier
  */
 async function identifiersConcatFromIdentifiers(_izContext, objType, identifiers) {
-  validateObjType(objType);
+  const validateObjTypeResult = validateObjType(objType);
+  if (validateObjTypeResult.errorsFound.length > 0) {
+    _izContext.logger.error("compositeIdentifierFromIdentifiersObject: Invalid objType: ", validateObjTypeResult.errorsFound);
+    throw new NoRetryError(`compositeIdentifierFromIdentifiersObject: Invalid objType: ${JSON.stringify(objType)}, ${validateObjTypeResult.errorsFound.join(", ")}`);
+  }
+
   _izContext.logger.debug("compositeIdentifierFromIdentifiersObject: ", { objType, identifiersObject: identifiers });
 
   const objSchema = await getSchema.getObjSchemaS3WithHierarchy(_izContext, objType);
@@ -315,7 +334,12 @@ async function identifiersConcatFromIdentifiers(_izContext, objType, identifiers
  * @returns {Promise<Object>}             - identifiersObject
  */
 async function identifiersFromIdentifiersConcat(_izContext, objType, identifiersConcat) {
-  validateObjType(objType);
+  const validateObjTypeResult = validateObjType(objType);
+  if (validateObjTypeResult.errorsFound.length > 0) {
+    _izContext.logger.error("identifiersObjectFromCompositeIdentifier: Invalid objType: ", validateObjTypeResult.errorsFound);
+    throw new NoRetryError(`identifiersObjectFromCompositeIdentifier: Invalid objType: ${JSON.stringify(objType)}, ${validateObjTypeResult.errorsFound.join(", ")}`);
+  }
+
   _izContext.logger.debug("identifiersObjectFromCompositeIdentifier: ", { objType, compositeIdentifier: identifiersConcat });
 
   const objSchema = await getSchema.getObjSchemaS3WithHierarchy(_izContext, objType);
@@ -423,8 +447,11 @@ async function createNestedIdentifiersConcat(
     throw new NoRetryError(`one of prefixes and suffixes should exists`);
   }
 
-  validateObjType(objType);
-
+  const validateObjTypeResult = validateObjType(objType);
+  if (validateObjTypeResult.errorsFound.length > 0) {
+    _izContext.logger.error("createConcatIdentifier: Invalid objType: ", validateObjTypeResult.errorsFound);
+    throw new NoRetryError(`createConcatIdentifier: Invalid objType: ${JSON.stringify(objType)}, ${validateObjTypeResult.errorsFound.join(", ")}`);
+  }
 
   const objSchema = await getSchema.getObjSchemaS3WithHierarchy(_izContext, objType);
   _izContext.logger.debug("objSchema in createConcatIdentifier", objSchema);
@@ -458,8 +485,11 @@ async function explodedNestedIdentifiersConcat(
     throw new NoRetryError(`invalid compositeIdentifier`);
   }
 
-  validateObjType(objType);
-
+  const validateObjTypeResult = validateObjType(objType);
+  if (validateObjTypeResult.errorsFound.length > 0) {
+    _izContext.logger.error("explodedConcatIdentifier: Invalid objType: ", validateObjTypeResult.errorsFound);
+    throw new NoRetryError(`explodedConcatIdentifier: Invalid objType: ${JSON.stringify(objType)}, ${validateObjTypeResult.errorsFound.join(", ")}`);
+  }
 
   const objSchema = await getSchema.getObjSchemaS3WithHierarchy(_izContext, objType);
   _izContext.logger.debug("objSchema in explodedConcatIdentifier", objSchema);

package/src/UploadObjSchema.js

@@ -48,7 +48,8 @@ const {
   validateObjectSchema,
   validateRelationshipSchema,
   validateRefRelationshipSchema,
-  validateBasicFlowSchema
+  validateBasicFlowSchema,
+  getApiLinks
 } = require('./Utils')
 
 const {
@@ -311,6 +312,7 @@ async function uploadObjectSchemaByUseCase(_izContext) {
 
     // case schema combine fieldNames
     let combineFieldNamesObjectSchema = generateObjectSchemaForCombineFieldNames(_izContext, objSchema);
+    console.log("combineFieldNamesObjectSchema", combineFieldNamesObjectSchema)
     uploadList.push(
       uploadObjectToS3(
         _izContext,
@@ -325,6 +327,23 @@ async function uploadObjectSchemaByUseCase(_izContext) {
       )
     );
 
+    let apiLink = await getApiLinks();
+    console.log("apiLink", apiLink)
+    uploadList.push(
+      uploadObjectToS3(
+        _izContext,
+        UPLOAD_PATH_S3.getEndpointPerObjectType(_izContext, { objectType: objSchema.objectType, serviceTag: process.env.iz_serviceTag }),
+        apiLink
+      )
+    )
+
+    uploadList.push(
+      uploadObjectToS3(
+        _izContext,
+        UPLOAD_PATH_S3.getEndpointPerService(process.env.iz_serviceTag),
+        apiLink
+      )
+    )
 
     // upload to refObjectRelationships for each objectType that have createBy at UserAccount Service and belongTo
     let existsRefObjectRel = refRelationshipPerObjectType[objSchema.objectType];

package/src/Utils.js

@@ -42,6 +42,13 @@ const consts = require('./Consts');
 // const getSchema = require('./GetObjectSchema');
 // const deliminatorTree = require('./libs/DeliminatorTree');
 
+const {
+  APIGatewayClient,
+  GetRestApisCommand,
+  GetResourcesCommand,
+  GetMethodCommand,
+} = require("@aws-sdk/client-api-gateway");
+
 function createObjType(objectType, serviceTag) {
   if (!process.env.iz_serviceTag && !serviceTag) {
     throw new NoRetryError('serviceNameTag not defined and  iz_serviceNameTag not defined in environment variables');
@@ -348,6 +355,9 @@ function validateObjectSchema(_izContext, objectSchema) {
       }
     }
   }
+  if (!objectSchema.hasOwnProperty("generatedBy")) {
+    objectSchema["generatedBy"] = "userGenerated"
+  };
 
   if (objectSchema.hasOwnProperty("extendObjType")) {
     return validateExtendObjectSchema(_izContext, objectSchema)
@@ -448,7 +458,11 @@ function validateRefRelationshipSchema(_izContext, refRelationshipSchema, servic
  * @returns
  */
 function findLinkByObjType(_izContext, objType, relationshipSchema) {
-  validateObjType(objType)
+  const validateObjTypeResult = validateObjType(objType);
+  if (validateObjTypeResult.errorsFound.length > 0) {
+    _izContext.logger.error(`findLinkByObjType: invalid objType: ${JSON.stringify(objType)}`);
+    throw new NoRetryError(`findLinkByObjType: invalid objType: ${JSON.stringify(objType)}`);
+  }
   let linkFounds = 0;
   let linkRecords = [];
 
@@ -495,7 +509,11 @@ function findLinkByObjType(_izContext, objType, relationshipSchema) {
  * @returns
  */
 function findLinkByObjTypeV2(_izContext, objType, relType, relationshipSchema) {
-  validateObjType(objType)
+  const validateObjTypeResult = validateObjType(objType);
+  if (validateObjTypeResult.errorsFound.length > 0) {
+    _izContext.logger.error(`findLinkByObjTypeV2: invalid objType: ${JSON.stringify(objType)}`);
+    throw new NoRetryError(`findLinkByObjTypeV2: invalid objType: ${JSON.stringify(objType)}`);
+  }
 
   const initialLinkData = {
     relType: {
@@ -555,8 +573,12 @@ function findLinkByObjTypeV2(_izContext, objType, relType, relationshipSchema) {
 
 
 function createObjTypeConcat(_izContext, objType) {
-  validateObjType(objType)
-  return `${objType.serviceTag}_${objType.objectType}`
+  const validateObjTypeResult = validateObjType(objType);
+  if (validateObjTypeResult.errorsFound.length > 0) {
+    _izContext.logger.error("createObjTypeConcat validateObjTypeResult", validateObjTypeResult);
+    throw new NoRetryError(`Invalid objType:${JSON.stringify(objType)}, ${validateObjTypeResult.errorsFound.join(", ")}`);
+  }
+  return `${objType.serviceTag}_${objType.objectType}`;
 }
 
 function explodedObjTypeConcat(_izContext, objectTypeId) {
@@ -564,8 +586,12 @@ function explodedObjTypeConcat(_izContext, objectTypeId) {
 }
 
 function createRelTypeConcat(_izContext, relType) {
-  validateRelType(relType)
-  return `${relType.serviceTag}_${relType.relationshipTag}`
+  const validateRelTypeResult = validateRelType(relType);
+  if (validateRelTypeResult.errorsFound.length > 0) {
+    _izContext.logger.error("createRelTypeConcat validateRelTypeResult", validateRelTypeResult);
+    throw new NoRetryError(`Invalid relType:${JSON.stringify(relType)}, ${validateRelTypeResult.errorsFound.join(", ")}`);
+  }
+  return `${relType.serviceTag}_${relType.relationshipTag}`;
 }
 
 function explodedRelTypeConcat(_izContext, relationshipTypeId) {
@@ -573,8 +599,12 @@ function explodedRelTypeConcat(_izContext, relationshipTypeId) {
 }
 
 function createFlowTypeConcat(_izContext, flowType) {
-  validateFlowType(flowType);
-  return `${flowType.serviceTag}_${flowType.flowTag}`
+  const validateFlowTypeResult = validateFlowType(flowType);
+  if (validateFlowTypeResult.errorsFound.length > 0) {
+    _izContext.logger.error("createFlowTypeConcat validateFlowTypeResult", validateFlowTypeResult);
+    throw new NoRetryError(`Invalid flowType:${JSON.stringify(flowType)}, ${validateFlowTypeResult.errorsFound.join(", ")}`);
+  }
+  return `${flowType.serviceTag}_${flowType.flowTag}`;
 }
 
 function explodedFlowTypeConcat(_izContext, flowTypeId) {
@@ -583,11 +613,25 @@ function explodedFlowTypeConcat(_izContext, flowTypeId) {
 
 function createLinkTypeId(_izContext, firstObjType, secondObjType, relType, direction) {
   // validate objType
-  validateObjType(firstObjType);
-  validateObjType(secondObjType);
+  let validateObjTypeResult = validateObjType(firstObjType);
+  if (validateObjTypeResult.errorsFound.length > 0) {
+    _izContext.logger.error("createLinkTypeId validateObjTypeResult", validateObjTypeResult);
+    throw new NoRetryError(`Invalid objType:${JSON.stringify(firstObjType)}, ${validateObjTypeResult.errorsFound.join(", ")}`);
+  }
+
+  validateObjTypeResult = validateObjType(secondObjType);
+  if (validateObjTypeResult.errorsFound.length > 0) {
+    _izContext.logger.error("createLinkTypeId validateObjTypeResult", validateObjTypeResult);
+    throw new NoRetryError(`Invalid objType:${JSON.stringify(secondObjType)}, ${validateObjTypeResult.errorsFound.join(", ")}`);
+  }
 
   // validate relType
-  validateRelType(relType);
+  let validateRelTypeResult = validateRelType(relType);
+
+  if (validateRelTypeResult.errorsFound.length > 0) {
+    _izContext.logger.error("createLinkTypeId validateRelTypeResult", validateRelTypeResult);
+    throw new NoRetryError(`Invalid relType:${JSON.stringify(relType)}, ${validateRelTypeResult.errorsFound.join(", ")}`);
+  }
 
   if (!direction || typeof direction !== "string" || (direction !== "from" && direction !== "to")) {
     throw new NoRetryError('getLinkConfigByLinkTypeId invalid direction');
@@ -631,6 +675,51 @@ function switchDirection(direction) {
   }
 }
 
+async function getApiLinks() {
+  try {
+    let apiGateway = {}
+    let position;
+    let foundApi;
+    const client = new APIGatewayClient({ region: process.env.iz_region });
+
+    do {
+      const apisRes = await client.send(new GetRestApisCommand({ position }));
+      // foundApi = apisRes.items.find(api => api.name === "Test-GCTpBas");
+      foundApi = apisRes.items.find(api => api.name === `${process.env.iz_stage}-${process.env.iz_serviceTag}`);
+
+      if (foundApi) break;
+      position = apisRes.position;
+    } while (position);
+
+    if (!foundApi) {
+      console.error("API not found");
+      return;
+    }
+
+    const resourcesRes = await client.send(
+      new GetResourcesCommand({ restApiId: foundApi.id })
+    );
+
+    for (const resource of resourcesRes.items) {
+      if (resource.resourceMethods) {
+        const methods = Object.keys(resource.resourceMethods);
+        for (const method of methods) {
+          const fullUrl = `https://${foundApi.id}.execute-api.${process.env.iz_region}.amazonaws.com/${process.env.iz_stage}${resource.path}`;
+          if (fullUrl.endsWith("Get") && (method === "POST")) {
+            Object.assign(apiGateway, {
+              Url: fullUrl
+            })
+          }
+        }
+      }
+    }
+    console.log("apiGateway in function getApiLink", apiGateway)
+    return apiGateway
+  } catch (err) {
+    console.error("Error fetching API info:", err);
+  }
+}
+
 module.exports = {
   createObjType,
   getIdentifierTypeByPriority,
@@ -656,4 +745,5 @@ module.exports = {
   explodedFlowTypeConcat,
 
   createLinkTypeId,
+  getApiLinks
 }

package/src/ValidatorSchema.js

@@ -241,7 +241,11 @@ async function validatorSchemaTreeIdentifiersFieldNames(_izContext, objectSchema
  * @param {String} objType.serviceTag
  */
 async function generateRelationshipValidatorSchemaForCreate(_izContext, objType) {
-  validateObjType(objType);
+  const validateObjTypeResult = validateObjType(objType);
+  if (validateObjTypeResult.errorsFound.length > 0) {
+    _izContext.logger.error("generateRelationshipValidatorSchemaForCreate validateObjTypeResult", validateObjTypeResult);
+    throw new NoRetryError(`Invalid objType:${JSON.stringify(objType)}, ${validateObjTypeResult.errorsFound.join(", ")}`);
+  }
 
   let relValidatorSchemas = {
     type: "array",
@@ -374,7 +378,11 @@ async function generateRelationshipValidatorSchemaForCreate(_izContext, objType)
  * @returns
  */
 async function generateValidatorSchemaForCreate(_izContext, objType, specificFieldNames = []) {
-  validateObjType(objType);
+  const validateObjTypeResult = validateObjType(objType);
+  if (validateObjTypeResult.errorsFound.length > 0) {
+    _izContext.logger.error("generateValidatorSchemaForCreate validateObjTypeResult", validateObjTypeResult);
+    throw new NoRetryError(`Invalid objType:${JSON.stringify(objType)}, ${validateObjTypeResult.errorsFound.join(", ")}`);
+  }
   _izContext.logger.debug("Function:generateValidatorSchemaForCreate ", {
     objType,
     specificFieldNames
@@ -616,7 +624,11 @@ async function generateValidatorSchemaForUpdate(_izContext, objType, setting = {
  * @returns {object} json validator schema
  */
 async function generateValidatorSchemaForIdentifier(_izContext, objType) {
-  validateObjType(objType);
+  const validateObjTypeResult = validateObjType(objType);
+  if (validateObjTypeResult.errorsFound.length > 0) {
+    _izContext.logger.error("generateValidatorSchemaForIdentifier validateObjTypeResult", validateObjTypeResult);
+    throw new NoRetryError(`Invalid objType:${JSON.stringify(objType)}, ${validateObjTypeResult.errorsFound.join(", ")}`);
+  }
   _izContext.logger.debug("Function:generateValidatorSchemaForIdentifier ", {
     objType,
   })
@@ -653,7 +665,11 @@ async function generateValidatorSchemaForIdentifier(_izContext, objType) {
  * @returns
  */
 async function filteredFieldNamesOfValidatorSchema(_izContext, objType, requiredFieldNames, usedFieldNames) {
-  validateObjType(objType);
+  const validateObjTypeResult = validateObjType(objType);
+  if (validateObjTypeResult.errorsFound.length > 0) {
+    _izContext.logger.error("filteredFieldNamesOfValidatorSchema validateObjTypeResult", validateObjTypeResult);
+    throw new NoRetryError(`Invalid objType:${JSON.stringify(objType)}, ${validateObjTypeResult.errorsFound.join(", ")}`);
+  }
   _izContext.logger.debug("Function filteredFieldNamesOfValidatorSchema : ", {
     objType,
     requiredFieldNames,
@@ -695,7 +711,12 @@ async function filteredFieldNamesOfValidatorSchema(_izContext, objType, required
  * 3 >> not required, Use for validate only
  */
 async function generateValidatorSchemaForExplodedData(_izContext, objType) {
-  validateObjType(objType)
+  const validateObjTypeResult = validateObjType(objType);
+  if (validateObjTypeResult.errorsFound.length > 0) {
+    _izContext.logger.error("generateValidatorSchemaForExplodedData validateObjTypeResult", validateObjTypeResult);
+    throw new NoRetryError(`Invalid objType:${JSON.stringify(objType)}, ${validateObjTypeResult.errorsFound.join(", ")}`);
+  }
+
   let validatorSchema = {
     type: "object",
     required: [],
@@ -1128,15 +1149,14 @@ async function validateLocalSchema(_izContext, schemasPath, serviceConfigPath) {
             }
           })
         )
-        // validate dulicate link
+        // validate duplicate link
         let relSchemaLinkType = new Set();
         for (let link of relData.links) {
-          console.log("link", link)
-          let linkTypeRelSchema = createLinkTypeId(_izContext,
+          let linkTypeRelSchema = hash([
             link.from.objType,
             link.to.objType,
-            { relationshipTag: relTagName, serviceTag: iz_serviceTag},
-            "from"
+            { relationshipTag: relTagName, serviceTag: iz_serviceTag },
+            "from"]
           )
 
           if (!relSchemaLinkType.has(linkTypeRelSchema)) {

package/src/libs/RelSchemaLib.js

@@ -34,15 +34,18 @@ const { getObjTypeHierarchy } = require('../GetObjectSchema')
 async function findLinksByObjTypes(_izContext, objTypes, relatoinshipLinks) {
 
   if (!Array.isArray(relatoinshipLinks)) {
-    throw NoRetryError("relatoinshipLinks should be array");
+    throw new NoRetryError("relatoinshipLinks should be array");
   }
 
   if (!objTypes || !Array.isArray(objTypes) || objTypes.length !== 2) {
-    throw NoRetryError("function checkLinkValid: invalid objTypes");
+    throw new NoRetryError("function checkLinkValid: invalid objTypes");
   }
 
   for (const objType of objTypes) {
-    validateObjType(objType);
+    const validateObjTypeResult = validateObjType(objType);
+    if (validateObjTypeResult.errorsFound.length > 0) {
+      throw NoRetryError(`function checkLinkValid: invalid objType ${objType.name} - ${validateObjTypeResult.errorsFound.join(", ")}`);
+    }
   }
 
   const firstObjType = objTypes[0];

package/src/libs/s3Utils.js

@@ -61,7 +61,6 @@ async function getObjectS3Shared(param) {
 }
 
 async function getSchemaByName(params) {
-
   if (!params.schemaName || !params.getParams) {
     throw new NoRetryError(`getSchemaByName invalid parameters`);
   }
@@ -76,7 +75,10 @@ async function getSchemaByName(params) {
     Key: SCHEMA_NAME_PER_S3_PATH[params.schemaName](params.getParams)
   };
 
-  let [objectSchema] = await getObjectS3Shared(getDataParam);
+  let [objectSchema] = await getObjectS3Shared({
+    Bucket: getDataParam.Bucket,
+    Key: getDataParam.Key.result
+  });
 
 
   return objectSchema;