@izara_project/izara-market-library-service-schemas 1.0.10 → 1.0.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izara_project/izara-market-library-service-schemas",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "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

@@ -217,15 +217,15 @@ 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/`),
+      translateId: join(saveFilePath, `../src/generatedCode/TranslateId/source/`)
     };
 
 

package/src/TemplateManager/src/OutPerActionComplete/OutCreateComplete/mainFunction/template.ejs

@@ -68,31 +68,31 @@ module.exports.createObjectComplete = async (
     };
     // validate.
     if (!returnValue.hasOwnProperty("queryResult")) {
-      errorFounds.push("message is not have property queryResult, should be not happen");
+      errorsFound.push("message is not have property queryResult, should be not happen");
     };
     if (!returnValue.hasOwnProperty("objType")) {
-      errorFounds.push("message is not have property objType, should be not happen");
+      errorsFound.push("message is not have property objType, should be not happen");
     };
     if (!returnValue.hasOwnProperty("objInstanceFull")) {
-      errorFounds.push("message is not have property objInstance, should be not objInstance");
+      errorsFound.push("message is not have property objInstance, should be not objInstance");
     };
 
     if (status == "error" && errorsFound.length > 0) {
-      errorFounds.push(errorsFound);
+      errorsFound.push(errorsFound);
     } else if (status == "error" && errorsFound.length == 0) {
-      errorFounds.push("[invalid]statur is error not have errorfound form graphService");
+      errorsFound.push("[invalid]statur is error not have errorfound form graphService");
 
     };
     if (status === "complete" && errorsFound.length > 0) {
-      errorFounds.push("[Invalid] status is commplete should be not have errorsFound");
+      errorsFound.push("[Invalid] status is commplete should be not have errorsFound");
     };
     if (graphServiceTag == null) {
-      errorFounds.push("[Invalid] graphServerTag is not empty string");
+      errorsFound.push("[Invalid] graphServerTag is not empty string");
     };
 
     if (errorsFound.length > 0) {
       _izContext.logger.debug("Have error form grapService:", errorsFound);
-      errorFounds = errorFounds.concat(errorsFound);
+      errorsFound = errorsFound.concat(errorsFound);
     };
 
     let awaitingStepId = await asyncFlowSharedLib.createAwaitingStepId(
@@ -159,8 +159,8 @@ module.exports.createObjectComplete = async (
     await sns.publishAsync(_izContext, sendMessageOutCreateObjectComplete);
 
     return {
-      objType: returnValue.objType,
-      objInstanceFull: returnValue.objInstanceFull,
+      returnValue: returnValue,
+      status: status,
       errorsFound: errorsFound
     }
 

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/Handler/HdrApi/template.ejs

@@ -35,7 +35,7 @@ const {
 //validate event params in middleware before into main function
 validateSchemaMiddleware(
   middleware,
-  "<%- firstLetterUpperCase(objectType) %>",
+  "<%- (objectType) %>",
   "<%- action %>"
   //(<validateSchemaSetting>
   //</validateSchemaSetting>)

package/src/TemplateManager/src/PerActionEndpoint/Handler/HdrInv/template.ejs

@@ -40,7 +40,7 @@ const {
 //validate event params in middleware before into function
 validateSchemaMiddleware(
   middleware,
-  "<%- firstLetterUpperCase(objectType) %>",                // objectType
+  "<%- (objectType) %>",                                   // objectType
   "<%- action %>",                                         // action
   //(<validateSchemaSetting>)
   //(</validateSchemaSetting>)

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`)
@@ -223,7 +223,8 @@ module.exports.<%- functionName %>Main = async (
           _izContext,
           MAIN_OBJTYPE,
           requireLink.other.objType,
-          requireLink.relType
+          requireLink.relType,
+          requireLink.base.direction
         );
 
         Object.assign(requiredOnCreateLinks, {
@@ -236,7 +237,8 @@ module.exports.<%- functionName %>Main = async (
           _izContext,
           MAIN_OBJTYPE,
           createRelationship.targetObjType,
-          createRelationship.relType
+          createRelationship.relType,
+          createRelationship.relationshipDirection
         );
 
         if (!requiredOnCreateLinks.hasOwnProperty(onCreateLinkTypeId)) {
@@ -277,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);
@@ -561,7 +563,7 @@ module.exports.<%- functionName %>Main = async (
       return {
         objType: MAIN_OBJTYPE,
         fieldNames: requestParams.fieldNames,
-        relationship: requestParams.relationships,
+        relationships: requestParams.relationships,
         status: "complete",
       }
     }