@izara_project/izara-market-library-service-schemas 1.0.11 → 1.0.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izara_project/izara-market-library-service-schemas",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "description": "Schemas for Izara Market project",
   "main": "index.js",
   "scripts": {
@@ -21,7 +21,7 @@
   },
   "dependencies": {
     "@izara_project/izara-core-library-core": "^1.0.13",
-    "@izara_project/izara-core-library-logger": "^1.0.5",
+    "@izara_project/izara-core-library-external-request": "^1.0.14",
     "@izara_project/izara-core-library-service-schemas": "^1.0.25",
     "@izara_project/izara-shared": "^1.0.96",
     "ejs": "^3.1.10",

package/src/GenerateCodeLibs/src/GenerateCodeLibs.js

@@ -47,6 +47,10 @@ const {
 
 const nodeLabelRegexPattern = "^[a-zA-Z0-9_-]+(?:\:[a-zA-Z0-9_-]+)?$"
 
+const RETURN_GET_DATA_FORMAT = {
+  std: "STD",     // { identifiers:{...}, fields:{...}} , data depend on getDataDetails
+  full: "FULL",   // {storageTag:{...getResult from database}}
+}
 
 const schemaFunctionPerAction = {
   [consts.ACTIONS.create]: validatorSchema.generateValidatorSchemaForCreate,
@@ -215,6 +219,20 @@ async function messageToDlq(record, messageFailError, queueUrl) {
 };
 
 
+// {
+//   [storageTag]: {
+//     storageType: 'graph',
+//     graphServiceTag: 'GraphHandler',
+//     fieldNames: [ 'companyName', 'companyId' ],
+//     versionedDatas: {
+//       ceo: [ 'name', 'ceoAddress', 'salary' ],
+//       branch: [ 'branchAddress', 'branchId' ]
+//     }
+//     versionedDataLabels:[],
+//   }
+// }
+
+
 /**
  * helper function for get endpoint
  * create get data detail for each storageTag
@@ -257,6 +275,10 @@ async function createGetDataDetails(_izContext, objectSchema) {
     // collect fieldNames per storageTag
     let storageTagFieldNames = [];
     for (let [fieldName, fieldNameData] of Object.entries(objectSchema.fieldNames)) {
+      // if (fieldName.startsWith("versionedDataField")) {
+      //   continue;
+      // }
+
       if (fieldNameData.storageResourceTags.includes(storageTag)) {
         storageTagFieldNames.push(fieldName);
       }
@@ -391,11 +413,20 @@ async function createGetDataDetails(_izContext, objectSchema) {
 
   _izContext.logger.debug("getDataDetailResults: ", getDataDetailResults);
 
+  for (const getDataDetail of Object.values(getDataDetailResults)) {
+    if (getDataDetail.hasOwnProperty("versionedDatas")) {
+      getDataDetail.versionedDataLabels = [];
+      for (let [versionedDataLabel, fieldNames] of Object.entries(getDataDetail.versionedDatas)) {
+        getDataDetail.versionedDataLabels.push(versionedDataLabel)
+        getDataDetail.fieldNames.push(...fieldNames);
+      }
+    }
+  }
+
   return getDataDetailResults;
 }
 
 
-
 /**
  * create dynamoDb identifiers using request param and objectSchema
  *
@@ -518,144 +549,165 @@ async function dynamoDbIdentifiersByStorageResource(_izContext, objectSchema, ge
 }
 
 
-
-function collectGetData(_izContext, getDataResult, getDataDetail) {
-
-  if (!getDataResult) {
-    return {};
+/**
+ * receive result from multiple database and create data format depend on returnFormat setting
+ *
+ * @param {object} _izContext
+ * @param {object[]} getResults
+ * @param {object} objectSchema
+ * @param {string} returnFormat
+ * @returns
+ */
+function collectGetData(_izContext, getResults, objectSchema, returnFormat = RETURN_GET_DATA_FORMAT.std) {
+  _izContext.logger.debug("collectGetData: ", {
+    getResults,
+    objectSchema,
+    returnFormat
+  });
+
+  if (returnFormat === "STD") {
+    return collectGetDataStdFormat(_izContext, getResults, objectSchema);
+  } else if (returnFormat === "FULL") {
+    return collectGetDataFullFormat(_izContext, getResults,)
+  } else {
+    throw new NoRetryError("invalid format");
   }
+}
 
-  let collectedData = {};
-
-  // if (getDataDetail.storageType === consts.STORAGE_TYPES.graph) {
-  //   // collect return data form main node only form properties
-  //   if (getDataResult.properties) {
-  //     for (let [mainFieldName, mainFieldNameValue] of Object.entries(getDataResult.properties)) {
-  //       if (getDataDetail.fieldNames.includes(mainFieldName)) {
-  //         Object.assign(collectedData, { [mainFieldName]: mainFieldNameValue });
-  //       }
-  //     }
-  //   }
-  if (getDataDetail.storageType === consts.STORAGE_TYPES.graph) {
-    if (getDataResult.objInstance) {
-      for (let [identifiersField, identifiersValues] of Object.entries(getDataResult.objInstance)) {
-        for (let [mainFieldName, mainFieldNameValue] of Object.entries(identifiersValues)) {
-          Object.assign(collectedData, {
-            [getDataDetail.graphServiceTag]: {
-              objType: {
-
-              },
-              objInstance: {
-                [mainFieldName]: mainFieldNameValue
-              }
-            }
-          })
-        }
-      }
-    }
 
+/**
+ * helper function for collectGetData
+ *
+ * @param {object} _izContext
+ * @param {object[]} getResults
+ * @param {set} identifierFieldNames
+ * @returns
+ */
+function collectGetDataStdFormat(_izContext, getResults, objectSchema) {
 
-    // collect data from versionedData
-    if (getDataDetail.hasOwnProperty("versionedDatas") && Object.keys(getDataDetail.versionedDatas).length) {
-      _izContext.logger.debug("getDataDetail has versionedData")
+  let collectedData = {
+    identifiers: {},
+    fields: {}
+  };
 
-      let versionedDataLabels = Object.keys(getDataDetail.versionedDatas);
+  const identifierFieldNames = new Set(utils.getUsedFieldNamesOfIdentifiers(_izContext, objectSchema.identifiers));
 
-      for (let versionedDataLabel of versionedDataLabels) {
+  let addedFieldNames = new Set();
 
-        _izContext.logger.debug(`per versionedData:${versionedDataLabel}`);
+  //  if isFound === true then return null from this function
+  let isFound = false;
 
-        if (getDataResult.versionedDatas[versionedDataLabel]?.properties
-          && Object.keys(getDataResult.versionedDatas[versionedDataLabel].properties).length
-        ) {
+  for (const [getData, getDataDetail] of getResults) {
+    if (!getData || !Object.keys(getData).length) {
+      continue;
+    }
 
-          _izContext.logger.debug(`has versionedData result:${versionedDataLabel}`);
+    // this process will add result from graph and dynamo to collectedData object by add identifiers and fieldName from getData
+    if (getDataDetail.storageType === consts.STORAGE_TYPES.graph) {
+      if (getData.objInstanceFull && Object.keys(getData.objInstanceFull).length) {
 
-          // let neededVersionedDataFieldNames = Object.keys(getDataDetail.versionedDatas[versionedDataLabel]);
+        for (const getDetailFieldName of getDataDetail.fieldNames) {
+          if (addedFieldNames.has(getDetailFieldName)) {
+            continue;
+          }
 
-          for (let neededVersionedDataFieldName of getDataDetail.versionedDatas[versionedDataLabel]) {
-            _izContext.logger.debug(`per needed versionedData fieldName:${versionedDataLabel}`);
-            if (getDataResult.versionedDatas[versionedDataLabel].properties.hasOwnProperty(neededVersionedDataFieldName)) {
-              Object.assign(collectedData, { [neededVersionedDataFieldName]: getDataResult.versionedDatas[versionedDataLabel].properties[neededVersionedDataFieldName] });
-            }
+          if (getData.objInstanceFull.identifiers.hasOwnProperty(getDetailFieldName)) {
+            Object.assign(
+              collectedData.identifiers,
+              { [getDetailFieldName]: getData.objInstanceFull.identifiers[getDetailFieldName] }
+            );
+            addedFieldNames.add(getDetailFieldName);
+            isFound = true;
+          } else if (getData.objInstanceFull.fields.hasOwnProperty(getDetailFieldName)) {
+            Object.assign(
+              collectedData.fields,
+              { [getDetailFieldName]: getData.objInstanceFull.fields[getDetailFieldName] }
+            );
+            addedFieldNames.add(getDetailFieldName);
+            isFound = true;
           }
         }
       }
-    }
-
-  } else if (getDataDetail.storageType === consts.STORAGE_TYPES.dynamoDB) {
-
-    // for (let [dynamoDbKey, dynamoDbValue] of Object.entries(getDataResult)) {
-    //   if (getDataDetail.fieldNames.includes(dynamoDbKey)) {
-    //     Object.assign(collectedData, { [dynamoDbKey]: dynamoDbValue });
-    //   }
-    // }
+    } else if (getDataDetail.storageType === consts.STORAGE_TYPES.dynamoDB) {
+      for (const getDetailFieldName of getDataDetail.fieldNames) {
+        if (addedFieldNames.has(getDetailFieldName)) {
+          continue;
+        }
 
-    for (let [dynamoDbKey, dynamoDbValue] of Object.entries(getDataResult)) {
-      // _izContext.logger.debug("dynamoDbKey::", dynamoDbKey);
-      // _izContext.logger.debug("dynamoDbValue::", dynamoDbValue);
-      if (getDataDetail.fieldNames.includes(dynamoDbKey)) {
-        Object.assign(collectedData, { [getDataDetail.tableName]: { [dynamoDbKey]: dynamoDbValue } });
+        if (getData.hasOwnProperty(getDetailFieldName)) {
+          if (identifierFieldNames.has(getDetailFieldName)) {
+            Object.assign(
+              collectedData.identifiers,
+              { [getDetailFieldName]: getData[getDetailFieldName] }
+            );
+            addedFieldNames.add(getDetailFieldName);
+            isFound = true;
+          } else {
+            Object.assign(
+              collectedData.fields,
+              { [getDetailFieldName]: getData[getDetailFieldName] }
+            );
+            addedFieldNames.add(getDetailFieldName);
+            isFound = true;
+          }
+        }
       }
+    } else {
+      throw new NoRetryError("collectGetData unhandled storageType");
     }
+  }
 
+  if (isFound) {
+    return collectedData;
   } else {
-    throw new NoRetryError(`Unhandled storageType:${getDataDetail.storageType}`);
+    return null;
   }
-
-  return collectedData
 }
 
-// old
-// function collectGetData(_izContext, getDataResult, getDataDetail) {
-
-//   if (!getDataResult) {
-//     return {};
-//   }
-
-//   let collectedData = {};
-
-//   if (getDataDetail.storageType === consts.STORAGE_TYPES.graph) {
-//     // collect return data form main node
-//     if (getDataResult.nodeProperties) {
-//       for (let [mainFieldName, mainFieldNameValue] of Object.entries(getDataResult.nodeProperties)) {
-//         if (getDataDetail.fieldNames.includes(mainFieldName)) {
-//           Object.assign(collectedData, { [mainFieldName]: mainFieldNameValue });
-//         }
-//       }
-//     }
+/**
+ *
+ * helper function for collectGetData
+ *
+ *  @param {object} _izContext
+ * @param {objects[]} getResults
+ * @returns
+ */
+function collectGetDataFullFormat(_izContext, getResults) {
+  let collectedData = {};
 
-//     // collect data from versionedData
-//     if (getDataDetail.hasOwnProperty("versionedDatas") && Object.keys(getDataDetail.versionedDatas).length) {
-//       let versionedDataLabels = Object.keys(getDataDetail.versionedDatas);
+  //  if isFound === true then return null from this function
+  let isFound = false;
 
-//       for (let versionedDataLabel of versionedDataLabels) {
-//         if (getDataResult[versionedDataLabel]?.nodeProperties && Object.keys(getDataResult[versionedDataLabel].nodeProperties).length) {
-//           let neededVersionedDataFieldNames = getDataDetail.versionedDatas[versionedDataLabel];
 
-//           for (let neededVersionedDataFieldName of neededVersionedDataFieldNames) {
-//             if (getDataResult[versionedDataLabel].nodeProperties[neededVersionedDataFieldName]) {
-//               Object.assign(collectedData, { [neededVersionedDataFieldName]: getDataResult[versionedDataLabel].nodeProperties[neededVersionedDataFieldName] });
-//             }
-//           }
-//         }
-//       }
-//     }
+  for (const [getData, getDataDetail] of getResults) {
+    if (!getData || !Object.keys(getData).length) {
+      continue;
+    }
 
-//   } else if (getDataDetail.storageType === consts.STORAGE_TYPES.dynamoDB) {
+    // this process will add result from graph and dynamo to collectedData object by add identifiers and fieldName from getData
+    if (getDataDetail.storageType === consts.STORAGE_TYPES.graph) {
+      if (getData.objInstanceFull?.identifiers && Object.keys(getData.objInstanceFull?.identifiers).length) {
+        Object.assign(collectedData, { [getDataDetail.graphServiceTag]: getData });
+        isFound = true;
+      }
+    } else if (getDataDetail.storageType === consts.STORAGE_TYPES.dynamoDB) {
 
-//     for (let [dynamoDbKey, dynamoDbValue] of Object.entries(getDataResult)) {
-//       if (getDataDetail.fieldNames.includes(dynamoDbKey)) {
-//         Object.assign(collectedData, { [dynamoDbKey]: dynamoDbValue });
-//       }
-//     }
+      if (getData && Object.keys(getData).length) {
+        Object.assign(collectedData, { [getDataDetail.tableName]: getData });
+        isFound = true;
+      }
+    } else {
+      throw new NoRetryError("collectGetData unhandled storageType");
+    }
+  }
 
-//   } else {
-//     throw new NoRetryError(`Unhandled storageType:${getDataDetail.storageType}`);
-//   }
+  if (isFound) {
+    return collectedData;
+  } else {
+    return null;
+  }
+}
 
-//   return collectedData
-// }
 
 async function createUpdateDataDetail(_izContext, objectSchema) {
   let getGraphDataDetails = {};
@@ -899,10 +951,11 @@ module.exports = {
   validateSchemaPerRecord,
 
   createGetDataDetails,
+  collectGetData,
+
   generateDynamoDbIdentifiers,
   generateDynamoDbIdentifiersWithCache,
   dynamoDbIdentifiersByStorageResource,
-  collectGetData,
   createUpdateDataDetail,
   createDataDetailsLib,
   createDeleteDataDetail

package/src/TemplateManager/src/GenerateCode.js

@@ -160,22 +160,6 @@ const createDeleteRelationshipCompleteHandler = require('./RelationshipPerAction
 const createDeleteRelationshipCompleteSnsAndSqs = require('./RelationshipPerAction/DeleteRelationship/DeleteRelationshipComplete/sns-in-sqs/data');
 const createDeleteRelationshipCompleteSnsOut = require('./RelationshipPerAction/DeleteRelationship/DeleteRelationshipComplete/sns-out/data');
 
-// TranslateIdRequest
-const createTranslateIdsCacheMainTable = require('./TranslateIdReq/TranslateIds/resourceYaml/dynamoDb/data');
-const createTranslateIdsRequestMainFunction = require('./TranslateIdReq/TranslateIds/mainFunction/data');
-const createTranslateIdsHandlerDsq = require('./TranslateIdReq/TranslateIds/handler/HdrDsq/data');
-const createTranslateIdsHandlerSqs = require('./TranslateIdReq/TranslateIds/handler/HdrSqs/data');
-const createTranslateIdFunctionYamlHdrDsq = require('./TranslateIdReq/TranslateIds/functionYaml/HdrDsq/data');
-const createTranslateIdFunctionYamlHdrSqs = require('./TranslateIdReq/TranslateIds/functionYaml/HdrSqs/data');
-const createSnsAndSqsTranslateId = require('./TranslateIdReq/TranslateIds/resourceYaml/sns-sqs/data');
-
-
-// processTranslateIds
-const createProcessTranslateIdsCompleteSnsOut = require('./TranslateIdReq/ProcessingTranslateIds/sns-out/data');
-const createTranslateIdsProcessSnsQueue = require('./TranslateIdReq/ProcessingTranslateIds/sqs-sns/data');
-const createTranslateIdsProcessFunctionYaml = require('./TranslateIdReq/ProcessingTranslateIds/functionYaml/data');
-const createTranslateIdsProcessHandler = require('./TranslateIdReq/ProcessingTranslateIds/handler/dataHdrDsq');
-const createTranslateIdsProcessMainFunction = require('./TranslateIdReq/ProcessingTranslateIds/mainFunction/data')
 // findData
 const createFindDataFunctionYaml = require('./FindData/FindDataYaml/data');
 const createFindDataHandler = require('./FindData/Handler/data');
@@ -196,6 +180,11 @@ const createProcessLogicalPaginateFunctionYamlHdrSqs = require('./ProcessLogical
 //get functionNameConfig
 const functionNameConfigFile = require('./externalService/FunctionNameConfig/data')
 
+//lib of generateCode
+const { checkValidTableYaml } = require('./libs/GenerateCodeUtils');
+
+const { NoRetryError } = require('@izara_project/izara-core-library-core');
+
 /**
  *
  * get template and send to
@@ -217,15 +206,14 @@ async function generateCodeWithTemplate(_izContext, objSchemaPath) {
 
     // define path for store yml file
     const GENERATECODE_SOURCE_PATH = {
-      appYaml: join(saveFilePath, `../sls_yaml/generatedCode/`),
-      resourceYaml: join(saveFilePath, `../../resource/sls_yaml/generatedCode/`),
-      lambdaPerAction: join(saveFilePath, '../src/generatedCode/ObjectTypePerActionEndpoint/'),
+      appYaml: join(saveFilePath, `../sls_yaml/generatedCode/source/`),
+      resourceYaml: join(saveFilePath, `../../resource/sls_yaml/generatedCode/source/`),
+      lambdaPerAction: join(saveFilePath, '../src/generatedCode/ObjectTypePerActionEndpoint/source/'),
       externalService: join(saveFilePath, '../initial_setup/generatedCode/source/'),
       resourceLocation: join(saveFilePath, 'src/generatedCode/perAction/source/'),
       lamdaPerCombindActionPath: join(saveFilePath, `/generatedCode/lamdaPerCombindAction/source/`), // test
-      lambdaPerObjectTypePath: join(saveFilePath, `/generatedCode/lambdaPerObjectType/`),  // test
-      updateRelationship: join(saveFilePath, `../src/generatedCode/RelationshipPerAction/`),
-      translateId: join(saveFilePath, `../src/generatedCode/TranslateId/`)
+      lambdaPerObjectTypePath: join(saveFilePath, `/generatedCode/lambdaPerObjectType/source/`),  // test
+      updateRelationship: join(saveFilePath, `../src/generatedCode/RelationshipPerAction/source/`),
     };
 
 
@@ -248,6 +236,9 @@ async function generateCodeWithTemplate(_izContext, objSchemaPath) {
 
     let createSourceParams = [];
 
+    // use to check dynamoDB table yaml, to prevent duplicate tableName
+    let createdTableYaml = {};
+
     for (const relTag in allObjectRelationships) {
       // const relTagData = allObjectRelationships[relTag];
 
@@ -288,12 +279,19 @@ async function generateCodeWithTemplate(_izContext, objSchemaPath) {
       const createFunctionYaml = [...createFunctionYamlHdrApi, ...createFunctionYamlHdrDsq, ...createFunctionYamlHdrInv, ...createFunctionYamlHdrSqs];
 
       // generate Resource ..via dynamoDb sns-in-sqs sns-put
-      const createResourceDynamo = createSourceDataDynamoDB(_izContext, objectSchema, saveFilePath);
+      let [createResourceDynamo, newCreatedTableYaml] = checkValidTableYaml(
+        _izContext,
+        createSourceDataDynamoDB(_izContext, objectSchema, saveFilePath),
+        createdTableYaml
+      );
+
+      createdTableYaml = newCreatedTableYaml;
+      _izContext.logger.debug("createResourceDynamo: ", createResourceDynamo);
+
       const createResourceSnsInSqs = createSourceSnsAndSqs(_izContext, objectSchema, saveFilePath);
       const createResourceSnsOut = createDataForCreateSourceSnsOut(_izContext, objectSchema, saveFilePath);
 
       // translateIdsMainFunction
-      const translateIdsMainFunction = await createTranslateIdsRequestMainFunction(_izContext, objectSchema, saveFilePath);
 
       // wrap main Resource
       const createMainResource = [...createResourceDynamo, ...createResourceSnsInSqs, ...createResourceSnsOut];
@@ -301,11 +299,10 @@ async function generateCodeWithTemplate(_izContext, objSchemaPath) {
 
       createSourceParams = createSourceParams.concat([
         // ...createSourceMainResourcesObjectSchema,
-        ...createSourceHandler,                                                                                   // create handler function
-        ...createMainFunction,                                                                                 // create main function
-        ...createFunctionYaml,                                                                                    // create function.yaml
-        ...createMainResource,                                                                                     // create resource yaml
-        ...translateIdsMainFunction,
+        ...createSourceHandler,       // create handler function
+        ...createMainFunction,        // create main function
+        ...createFunctionYaml,        // create function.yaml
+        ...createMainResource,        // create resource yaml
       ]);
 
       // console.log("createSourceParams after concat: ", createSourceParams);
@@ -446,24 +443,6 @@ async function generateCodeWithTemplate(_izContext, objSchemaPath) {
 
     const deleteRelationshipCompleteData = [...deleteRelationshipCompleteFunctionYaml, ...deleteRelationshipCompleteMainFunction, ...deleteRelationshipCompleteHandler, ...deleteRelationshipCompleteSnsAndSqs, ...deleteRelationshipCompleteSnsOut]
 
-    const translateIdsCacheIdsMainTable = createTranslateIdsCacheMainTable(_izContext, saveFilePath);
-    const translateIdsHandlerFunctionDsq = createTranslateIdsHandlerDsq(_izContext, saveFilePath);
-    const translateIdsHandlerFunctionSqs = createTranslateIdsHandlerSqs(_izContext, saveFilePath);
-    const translateIdsFunctionYamlDsq = createTranslateIdFunctionYamlHdrDsq(_izContext, saveFilePath);
-    const translateIdsFunctionYamlSqs = createTranslateIdFunctionYamlHdrSqs(_izContext, saveFilePath);
-    const translateIdsSnsAndSqsResourceQueue = createSnsAndSqsTranslateId(_izContext, saveFilePath);
-
-    const createTranslateIdsResourece = [...translateIdsCacheIdsMainTable, ...translateIdsHandlerFunctionDsq, ...translateIdsHandlerFunctionSqs,
-    ...translateIdsFunctionYamlDsq, ...translateIdsFunctionYamlSqs, ...translateIdsSnsAndSqsResourceQueue
-    ]
-
-    const translateIdsProcessingSnsOut = createProcessTranslateIdsCompleteSnsOut(_izContext, saveFilePath);
-    const translateIdsProcessingQueue = createTranslateIdsProcessSnsQueue(_izContext, saveFilePath);
-    const translateIdsProcessingFunctionYaml = createTranslateIdsProcessFunctionYaml(_izContext, saveFilePath);
-    const translateIdsProcessingHandler = createTranslateIdsProcessHandler(_izContext, saveFilePath);
-    const translateIdsProcessingMainFunction = createTranslateIdsProcessMainFunction(_izContext, saveFilePath);
-    const createTranslateIdsProcessing = [...translateIdsProcessingQueue, ...translateIdsProcessingFunctionYaml, ...translateIdsProcessingHandler, ...translateIdsProcessingMainFunction, ...translateIdsProcessingSnsOut]
-
     const findDataHandlerSqs = createFindDataHandler(_izContext, saveFilePath);
     const findDataMainFunction = await createFindDataMainFunction(_izContext, saveFilePath);
 
@@ -494,8 +473,6 @@ async function generateCodeWithTemplate(_izContext, objSchemaPath) {
       createSourceParams.push(
         ...updateRelationshipSchemaDatas,
         ...createRelationshipSchemaDatas,
-        ...createTranslateIdsResourece,
-        ...createTranslateIdsProcessing,
         ...deleteRelationshipData,
         ...deleteRelationshipCompleteData
       )

package/src/TemplateManager/src/PerActionEndpoint/Handler/HdrApi/data.js

@@ -28,7 +28,7 @@ const templatePath = path.join(__dirname, "./template.ejs")
 
 /**
  * receive objectSchema
- * create data for hdrInv template
+ * create data for hdrApi template
  *
  * @param {Object} objectSchema
  * @return {{ templatePath, templateData, setting } }
@@ -38,10 +38,10 @@ function data(_izContext, objectSchema, srcPath) {
 
   for (const action of Object.values(ACTIONS)) {
     if (objectSchema.overWriteHandlers?.[action]) {
-      // if have overWriteHander of action check hdrInv inside
+      // if have overWriteHander of action check hdrApi inside
       if (objectSchema.overWriteHandlers[action].includes(HANDLER.hdrApi)) {
         // create template data
-        const createSourceParam = createParamForCreateSource(objectSchema, action, HANDLER.hdrInv, srcPath)
+        const createSourceParam = createParamForCreateSource(objectSchema, action, HANDLER.hdrApi, srcPath)
         createSourceArray.push(createSourceParam)
       }
     } else {
@@ -49,7 +49,7 @@ function data(_izContext, objectSchema, srcPath) {
       const defaultHandler = DEFAULT_HANDLER_PER_ACTION[action]
       if (defaultHandler.includes(HANDLER.hdrApi)) {
         // create template data and object for create source
-        const createSourceParam = createParamForCreateSource(objectSchema, action, HANDLER.hdrInv, srcPath)
+        const createSourceParam = createParamForCreateSource(objectSchema, action, HANDLER.hdrApi, srcPath)
         createSourceArray.push(createSourceParam)
       }
     }

package/src/TemplateManager/src/PerActionEndpoint/MainFunction/Create/template.ejs

@@ -95,7 +95,7 @@ module.exports.<%- functionName %>Main = async (
 
     let errorsFound = [];
 
-    _izContext.correlationIds.set(coreConsts.BASE_USER_ID, "BasDev");
+    // _izContext.correlationIds.set(coreConsts.BASE_USER_ID, "BasDev");
     const userId = _izContext.correlationIds.get(coreConsts.BASE_USER_ID);
     if (!userId) {
       errorsFound.push("Not have userId")
@@ -211,7 +211,7 @@ module.exports.<%- functionName %>Main = async (
     _izContext.logger.debug("filteredRequiredOnCreatedLinks", filteredRequiredOnCreatedLinks);
 
     if (filteredRequiredOnCreatedLinks.length) {
-      if (!requestParams.relationships.length) {
+      if (!requestParams.relationships || !requestParams.relationships.length) {
         // in case not send relationship to create with
         for (const requireLink of filteredRequiredOnCreatedLinks) {
           errorsFound.push(`missing required relationship of relType ${JSON.stringify(requireLink.relType)} when create`)
@@ -279,7 +279,7 @@ module.exports.<%- functionName %>Main = async (
     let allAwaitingStepsId = [];
 
     // validate single identifiers
-    if (objectSchemas.identifiers.length === 1 && !objectSchemas.identifiers.hasOwnProperty("fieldNames")) {
+    if (objectSchemas.identifiers.length === 1 && !objectSchemas.identifiers[0].hasOwnProperty("fieldNames")) {
 
       const identifier = objectSchemas.identifiers[0];
       _izContext.logger.debug(":::::case single identifer:::::", identifier);