@izara_project/izara-core-library-service-schemas 1.0.72 → 1.0.74

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izara_project/izara-core-library-service-schemas",
-  "version": "1.0.72",
+  "version": "1.0.74",
   "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.3"
   },
   "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.840.0",
+    "@aws-sdk/client-s3": "^3.840.0",
+    "@aws-sdk/crc64-nvme-crt": "^3.840.0",
+    "@aws-sdk/client-api-gateway": "^3.840.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.20",
+    "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
+    }
   }
 
 
@@ -209,13 +220,17 @@ async function getLocalObjectSchemas(_izContext, objectTypes, objSchemaPath = LO
   if (getExtendObType) {
     await Promise.all(
       allObjectSchemas.map(async (objSchema, idx) => {
-        allObjectSchemas[idx] = await mergeExtendObjSchema(_izContext, objSchema).then(res => res.result);
+        const mergeResult = await mergeExtendObjSchema(_izContext, objSchema)
+        if (mergeResult?.errorsFound?.length && mergeResult?.errorsFound?.length > 0) {
+          throw new NoRetryError(mergeResult.errorsFound.join(","))
+        } else {
+          allObjectSchemas[idx] = mergeResult;
+        }
       })
     )
   }
 
 
-
   // add objectSchema to returnValue object
   for (let [idx, objSchema] of allObjectSchemas.entries()) {
     if (!returnValue.fieldLookup.hasOwnProperty(objSchema.objectType)) {
@@ -233,7 +248,8 @@ async function getLocalObjectSchemas(_izContext, objectTypes, objSchemaPath = LO
   }
   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,7 +311,9 @@ async function getAllLocalObjectSchemas(_izContext, objSchemaPath = LOCAL_OBJECT
   if (getExtendObType) {
     await Promise.all(
       allObjectSchemas.map(async (objSchema, idx) => {
-        allObjectSchemas[idx] = await mergeExtendObjSchema(_izContext, objSchema).then(res => res.result)
+        const mergeResult = await mergeExtendObjSchema(_izContext, objSchema)
+
+        allObjectSchemas[idx] = mergeResult;
       })
     )
   }
@@ -305,7 +322,11 @@ async function getAllLocalObjectSchemas(_izContext, objSchemaPath = LOCAL_OBJECT
     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)) {
@@ -319,8 +340,7 @@ async function getAllLocalObjectSchemas(_izContext, objSchemaPath = LOCAL_OBJECT
 
   returnValue.records = allObjectSchemas;
 
-  return returnValue;
-
+  return returnValue
 }
 
 /**
@@ -449,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.join(","))
+    } else {
+      return res.result
+    }
+  });
 }
 
 
@@ -477,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.join(","))
+    } else {
+      return res.result
+    }
+  });
 }
 
 /**
@@ -488,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.join(","))
+    } else {
+      return res.result
+    }
+  });
 }
 
 
@@ -504,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
 }
 
 /**
@@ -598,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.join(","))
+    } else {
+      return res.result
+    }
+  })
 }
 
 /**
@@ -627,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.join(","))
+    } else {
+      return res.result
+    }
+  })
 }
 
 
@@ -665,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,
@@ -683,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 {
@@ -714,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
@@ -730,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.join(","))
+    } else {
+      return res.result
+    }
+  })
 }
 
 
@@ -774,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.join(","))
+    } else {
+      return res.result
+    }
+  })
 }
 
 
@@ -850,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.join(","))
+    } else {
+      return res.result
+    }
+  });
 }
 
 /**
@@ -881,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
 }
 
 
@@ -965,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');
@@ -451,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 = [];
 
@@ -498,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: {
@@ -558,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) {
@@ -567,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) {
@@ -576,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) {
@@ -586,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');
@@ -634,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,
@@ -659,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/CreateNodeLib.js

@@ -26,22 +26,34 @@ async function validateRequiredOnCreateLinks(_izContext, objType, relationships,
   _izContext.logger.debug("validateRequiredOnCreateLinks:::", { objType, relationships, settings })
 
 
-  let objectHie = await getObjTypeHierarchy(_izContext, objType);
+  let objectHie = await getObjTypeHierarchy(_izContext, objType).then(objSchema => {
+    if (objSchema.errorsFound.length > 0) {
+      throw new NoRetryError(objSchema.errorsFound.join(","))
+    } else {
+      return objSchema.result
+    }
+  });
   _izContext.logger.debug("objectHierarchy::", objectHie)
 
   if (relationships.length) {
-    let targetHierarchy = await getObjTypeHierarchy(_izContext, relationships[0].targetObjType);
+    let targetHierarchy = await getObjTypeHierarchy(_izContext, relationships[0].targetObjType).then(objSchema => {
+      if (objSchema.errorsFound.length > 0) {
+        throw new NoRetryError(objSchema.errorsFound.join(","))
+      } else {
+        return objSchema.result
+      }
+    });
     _izContext.logger.debug("targetHierarchy::", targetHierarchy)
   }
 
 
-  let errorFound = [];
+  let errorsFound = [];
 
   let requiredOnCreateLinks = await getObjectSchema.getRequiredOnCreateLinksWithCache(_izContext, objType)
   _izContext.logger.debug("requiredOnCreateLinks::", requiredOnCreateLinks)
 
   if (!requiredOnCreateLinks.length && relationships.length > 0) {
-    errorFound.push(`not have requireOnCreate will not create relationship: ${JSON.stringify(relationships)}`)
+    errorsFound.push(`not have requireOnCreate will not create relationship: ${JSON.stringify(relationships)}`)
   }
 
   let filteredRequiredOnCreateLinks = [];
@@ -76,22 +88,28 @@ async function validateRequiredOnCreateLinks(_izContext, objType, relationships,
     let relTypeConcat = createRelTypeConcat(_izContext, relationship.relType)
 
     if (!requiredOnCreateLinkGroups[relTypeConcat]) {
-      errorFound.push(`cannot create relationship ${relTypeConcat}`)
+      errorsFound.push(`cannot create relationship ${relTypeConcat}`)
       break;
     }
 
     // match requiredOnCreateLinks with relationshipDirection from requestParams
     const usedLinkGroup = requiredOnCreateLinkGroups[relTypeConcat][relationship.relationshipDirection];
 
-    if (!usedLinkGroup.length) {
-      errorFound.push(`cannot create relationship ${relTypeConcat}`)
+    if (!usedLinkGroup?.length) {
+      errorsFound.push(`cannot create relationship ${relTypeConcat}`)
       break;
     }
 
     for (let link of usedLinkGroup) {
       // check other with targetObjType, check linkType of other should be 'one',
-      let targetObjTypeHierarchy = await getObjTypeHierarchy(_izContext, relationship.targetObjType);
-      _izContext.logger.debug(" ::", targetObjTypeHierarchy)
+      let targetObjTypeHierarchy = await getObjTypeHierarchy(_izContext, relationship.targetObjType).then(objSchema => {
+        if (objSchema.errorsFound.length > 0) {
+          throw new NoRetryError(objSchema.errorsFound.join(","))
+        } else {
+          return objSchema.result
+        }
+      });
+      _izContext.logger.debug("targetObjTypeHierarchy::", targetObjTypeHierarchy)
 
       // if (link.other.objType.objectType === relationship.targetObjType.objectType) {
       if (targetObjTypeHierarchy.some(objType =>
@@ -101,11 +119,11 @@ async function validateRequiredOnCreateLinks(_izContext, objType, relationships,
           if (!validateOnCreateRelationships.has(`${relTypeConcat}_${relationship.relationshipDirection}`)) {
             validateOnCreateRelationships.add(`${relTypeConcat}_${relationship.relationshipDirection}`)
           } else {
-            errorFound.push(`unexpected dulicate relationship link ${JSON.stringify(relationship)}`)
+            errorsFound.push(`unexpected duplicate relationship link ${JSON.stringify(relationship)}`)
             break;
           }
         } else {
-          errorFound.push(`invalid linkType should not be many when base: ${link} is requiredOnCreated`)
+          errorsFound.push(`invalid linkType should not be many when base: ${link} is requiredOnCreated`)
           break;
         }
       }
@@ -117,11 +135,11 @@ async function validateRequiredOnCreateLinks(_izContext, objType, relationships,
 
   for (const requiredOnCreateRelTypeConcat of requiredOnCreateRelTypeConcats) {
     if (!validateOnCreateRelationships.has(requiredOnCreateRelTypeConcat)) {
-      errorFound.push(`missing requiredOnCreate relationship ${requiredOnCreateRelTypeConcat}`)
+      errorsFound.push(`missing requiredOnCreate relationship ${requiredOnCreateRelTypeConcat}`)
     }
   }
 
-  return errorFound;
+  return errorsFound;
 }
 
 function groupRequiredOnCreateLink(_izContext, relationshipSchemas) {

package/src/libs/DeliminatorTree.js

@@ -205,24 +205,24 @@ async function generateDeliminatorTreeIdentifier(_izContext, objectSchema) {
           }));
 
           // calculate deliminatorTree of identifier
-          let calCompoisteKeyDeliminatorList = {};
+          let calCompositeKeyDeliminatorList = {};
           for (let deliminatorValue of Object.values(compositeKeysDeliminatorTree)) {
             if (deliminatorValue.deliminatorList) {
               for (let [deliminator, deliminatorAmount] of Object.entries(deliminatorValue.deliminatorList)) {
-                if (calCompoisteKeyDeliminatorList.hasOwnProperty(deliminator)) {
-                  calCompoisteKeyDeliminatorList[deliminator] = Math.max(deliminatorAmount, calCompoisteKeyDeliminatorList[deliminator]);
+                if (calCompositeKeyDeliminatorList.hasOwnProperty(deliminator)) {
+                  calCompositeKeyDeliminatorList[deliminator] = Math.max(deliminatorAmount, calCompositeKeyDeliminatorList[deliminator]);
                 } else {
-                  Object.assign(calCompoisteKeyDeliminatorList, { [deliminator]: deliminatorAmount });
+                  Object.assign(calCompositeKeyDeliminatorList, { [deliminator]: deliminatorAmount });
                 }
               }
             }
           }
 
 
-          if (calCompoisteKeyDeliminatorList.hasOwnProperty(identifierDeliminator)) {
-            calCompoisteKeyDeliminatorList[identifierDeliminator]++;
+          if (calCompositeKeyDeliminatorList.hasOwnProperty(identifierDeliminator)) {
+            calCompositeKeyDeliminatorList[identifierDeliminator]++;
           } else {
-            Object.assign(calCompoisteKeyDeliminatorList, { [identifierDeliminator]: 1 });
+            Object.assign(calCompositeKeyDeliminatorList, { [identifierDeliminator]: 1 });
           }
 
           Object.assign(
@@ -230,7 +230,7 @@ async function generateDeliminatorTreeIdentifier(_izContext, objectSchema) {
             {
               [identifierName]: {
                 deliminator: identifierDeliminator,
-                deliminatorList: calCompoisteKeyDeliminatorList,
+                deliminatorList: calCompositeKeyDeliminatorList,
                 children: compositeKeysDeliminatorTree
               }
             }

package/src/libs/RelSchemaLib.js

@@ -29,28 +29,43 @@ const { getObjTypeHierarchy } = require('../GetObjectSchema')
  *
  * @param {object} _izContext
  * @param {object[]} objTypes          - 2 objType in array
- * @param {object[]} relatoinshipLinks - links inside relationshipSchema
+ * @param {object[]} relationshipLinks - links inside relationshipSchema
  */
-async function findLinksByObjTypes(_izContext, objTypes, relatoinshipLinks) {
+async function findLinksByObjTypes(_izContext, objTypes, relationshipLinks) {
 
-  if (!Array.isArray(relatoinshipLinks)) {
-    throw NoRetryError("relatoinshipLinks should be array");
+  if (!Array.isArray(relationshipLinks)) {
+    throw new NoRetryError("relationshipLinks 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];
   const secondObjType = objTypes[1];
 
   // first create hierarchy of each objType
-  const firstObjTypeTree = await getObjTypeHierarchy(_izContext, objTypes[0]);
-  const secondObjTypeTree = await getObjTypeHierarchy(_izContext, objTypes[1]);
+  const firstObjTypeTree = await getObjTypeHierarchy(_izContext, objTypes[0]).then(objSchema => {
+    if (objSchema.errorsFound.length > 0) {
+      throw new NoRetryError(objSchema.errorsFound.join(","))
+    } else {
+      return objSchema.result
+    }
+  });
+  const secondObjTypeTree = await getObjTypeHierarchy(_izContext, objTypes[1]).then(objSchema => {
+    if (objSchema.errorsFound.length > 0) {
+      throw new NoRetryError(objSchema.errorsFound.join(","))
+    } else {
+      return objSchema.result
+    }
+  });
 
   const firstObjTypeTreeHashes = firstObjTypeTree.reduce(
     (result, objType) => {
@@ -71,7 +86,7 @@ async function findLinksByObjTypes(_izContext, objTypes, relatoinshipLinks) {
 
   let foundLinks = [];
 
-  for (let link of relatoinshipLinks) {
+  for (let link of relationshipLinks) {
     const fromObjTypeHash = hash(link.from.objType);
     const toObjTypeHash = hash(link.to.objType);
 

package/src/libs/UploadUseCase.js

@@ -100,6 +100,10 @@ function generateObjectSchemaForCreate(_izContext, objSchema) {
 
   for (let [fieldName, fieldNameSetting] of Object.entries(objSchema.fieldNames)) {
 
+    if (!fieldNameSetting.requiredOnCreate && !fieldNameSetting.optionalOnCreate) {
+      continue;
+    }
+
     if (!initReturnObj.fieldNames.hasOwnProperty(fieldName)) {
       initReturnObj.fieldNames[fieldName] = {}
     }
@@ -115,6 +119,11 @@ function generateObjectSchemaForCreate(_izContext, objSchema) {
     for (let addOn of objSchema.addOnDataStructure) {
       if (addOn.type === "versionedData") {
         for (let [versionedFieldName, fieldNameData] of Object.entries(addOn.fieldNames)) {
+
+          if (!fieldNameData.requiredOnCreate && !fieldNameData.optionalOnCreate) {
+            continue;
+          }
+
           Object.assign(
             initReturnObj.fieldNames,
             {
@@ -134,8 +143,6 @@ function generateObjectSchemaForCreate(_izContext, objSchema) {
   return initReturnObj;
 }
 
-
-
 /**
  * create object schema for update/display case
  *