@izara_project/izara-market-library-service-schemas 1.0.22 → 1.0.24

package/src/reStructure/TemplateData/perActionEndpoint/mainFunction/update/template.ejs

@@ -0,0 +1,351 @@
+/*
+Copyright (C) 2020 Sven Mason <http: //izara.io>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program. If not, see
+<http: //www.gnu.org/licenses />.
+*/
+
+'use strict';
+
+const hash = require("object-hash");
+const {
+  getObjSchemaS3WithHierarchy,
+} = require('@izara_project/izara-core-library-service-schemas/src/GetObjectSchema');
+
+
+const consts = require('@izara_project/izara-core-library-service-schemas/src/Consts');
+
+
+const {
+  dynamoDbIdentifiersByStorageResource,
+  createFieldForUpdateDynamoDb
+} = require('@izara_project/izara-market-library-service-schemas/src/GenerateCodeLibs/src/GenerateCodeLibs');
+
+const izaraShared = require('@izara_project/izara-shared');
+const dynamodbSharedLib = izaraShared.dynamodbSharedLib;
+const snsSharedLib = izaraShared.snsSharedLib;
+const asyncFlowSharedLib = izaraShared.asyncFlowSharedLib;
+const callingFlowSharedLib = izaraShared.callingFlowSharedLib;
+const lambdaSharedLib = izaraShared.lambdaSharedLib
+
+const externalRequest = require('@izara_project/izara-core-library-external-request');
+const sns = externalRequest.sns
+
+const { createUpdateDataDetail } = require("@izara_project/izara-market-library-service-schemas/src/GenerateCodeLibs/src/GenerateCodeLibs")
+const { PREFIX, TOPIC_NAME_GENERATE_CODE, TOPIC_NAME_GRAPH_HANDLER } = require('@izara_project/izara-market-library-service-schemas/src/GenerateCodeLibs/src/Consts');
+const coreConsts = require('@izara_project/izara-core-library-core/src/Consts')
+
+/**
+ *
+ *
+ * description of function.
+ * @param {Object} _izContext
+ * @param {CorrelationIds} _izContext.correlationIds - property of _izContext
+ * @param {Logger} _izContext.logger - property of _izContext
+ * @param {Object} requestParams - request params
+ * @param {Object} requestParams.identifiers - identifiers for get data
+ * @param {Object} requestParams.additionalRequest - additionalRequest
+ *
+ *
+ * @returns {object} description of return value
+ */
+
+module.exports.<%- functionName %>Main = async (
+  _izContext,
+  requestParams,
+  callingFlowConfig = {},
+  //(<additionalParams>)
+  //(</additionalParams>)
+) => {
+
+  try {
+    _izContext.logger.debug("<%- functionName %> _izContext", _izContext)
+    _izContext.logger.debug("<%- functionName %> requestParams", requestParams)
+    _izContext.logger.debug("<%- functionName %> callingFlowConfig", callingFlowConfig)
+
+    let errorFounds = [];
+    const userId = _izContext.correlationIds.get(coreConsts.BASE_USER_ID);
+    const targetId = _izContext.correlationIds.get(coreConsts.TARGET_ID);
+
+    if (!userId) {
+      errorFounds.push("Not have userId")
+    }
+
+    const OBJECT_TYPE = "<%- objectType %>"
+    const SERVICE_TAG = process.env.iz_serviceTag;
+    //(<beforeQuery>)
+    //(</beforeQuery>)
+
+    const identifiers = requestParams.objInstanceFull.identifiers;
+    const fields = requestParams.objInstanceFull.fields
+    let versionedDataIds = requestParams.versionedDataIds || {}
+
+    _izContext.logger.debug("explode requestParams", {
+      identifiers: identifiers,
+      fields: fields,
+      versionedDataIds: versionedDataIds
+    })
+    let objectSchema = await getObjSchemaS3WithHierarchy(
+      _izContext,
+      {
+        objectType: OBJECT_TYPE,
+        serviceTag: SERVICE_TAG
+      }
+    )
+    _izContext.logger.debug("objectSchema", objectSchema);
+
+    if (objectSchema.hasOwnProperty("belongTo") && !targetId) {
+      errorFounds.push('not have targetId')
+    }
+
+    let updateDataDetails = await createUpdateDataDetail(_izContext, objectSchema);
+
+    _izContext.logger.debug("updateDataDetails", updateDataDetails);
+
+    let originTimestamp = Date.now();
+
+    let haveVersionedDataIdsToUpdate = (requestParams.versionedDataIds && Object.keys(requestParams.versionedDataIds).length) ? true : false
+    if (haveVersionedDataIdsToUpdate) {
+
+      let updateMainNodeData = {};
+      let updateVersionedData = {};
+      _izContext.logger.debug("have versionedDataIds to update")
+      for (const fieldProp in requestParams.objInstanceFull.fields) {
+        const fieldSetting = objectSchema.fieldNames[fieldProp];
+        // collect updateData
+        if (fieldSetting.hasOwnProperty("versionedDataLabel")) {
+          if (!updateVersionedData.hasOwnProperty(fieldSetting.versionedDataLabel)) {
+            updateVersionedData[fieldSetting.versionedDataLabel] = {};
+          }
+          Object.assign(updateVersionedData[fieldSetting.versionedDataLabel], {
+            [fieldProp]: requestParams.objInstanceFull.fields[fieldProp]
+          })
+        } else {
+          Object.assign(updateMainNodeData, {
+            [fieldProp]: requestParams.objInstanceFull.fields[fieldProp]
+          })
+        }
+      }
+      _izContext.logger.debug("updateMainNodeData::", updateMainNodeData);
+      _izContext.logger.debug("updateVersionedData::", updateVersionedData);
+
+      const versionedDataIdLabelKeys = Object.keys(requestParams.versionedDataIds);
+      const updateVersionedDataLabelKeys = Object.keys(updateVersionedData);
+
+      _izContext.logger.debug("versionedDataIdLabelKeys:: ", versionedDataIdLabelKeys);
+      _izContext.logger.debug("updateVersionedDataLabelKeys:: ", updateVersionedDataLabelKeys);
+      //check missing versionedDataIds
+      const missingVersionedDataIdLabels = updateVersionedDataLabelKeys.filter(label => !versionedDataIdLabelKeys.includes(label));
+      _izContext.logger.debug("missingVersionedDataIdLabels:: ", missingVersionedDataIdLabels);
+
+      if (missingVersionedDataIdLabels.length) {
+        errorFounds.push(`missing versionedDataIds of versionedDataLabel '${missingVersionedDataIdLabels.join(", ")}'`)
+      }
+
+      // check missing update data of versionedDataLabels
+      const missingDataVersionedDataLabels = versionedDataIdLabelKeys.filter(label => !versionedDataIdLabelKeys.includes(label))
+      if (missingDataVersionedDataLabels.length) {
+        errorFounds.push(`missing data of versionedDataLabels '${missingDataVersionedDataLabels.join(", ")}'`);
+      }
+      // check mainNode Data should not exists
+      if (Object.keys(updateMainNodeData).length) {
+        errorFounds.push("cannot update mainNode if have versionedDataIds");
+      }
+    }
+
+    let messageAttributes
+
+    if (errorFounds.length) {
+      let updateNodeCompleteMessage = {
+        objType: {
+          objecType: OBJECT_TYPE,
+          serviceTag: SERVICE_TAG
+        },
+        objInstanceFull: {
+          identifiers: identifiers,
+          fields: fields,
+        },
+        versionedDataIds: versionedDataIds,
+        status: 'error',
+        errorFounds: errorFounds
+      };
+
+
+      updateNodeCompleteMessage = callingFlowSharedLib.addPassBackPropertiesToSnsResponseMessageObject(callingFlowConfig, updateNodeCompleteMessage);
+      messageAttributes = callingFlowSharedLib.addCallingFlowToSnsResponseMessageAttributes(callingFlowConfig, {})
+
+      let messageParams = {
+        Message: JSON.stringify(updateNodeCompleteMessage),
+        MessageAttributes: sns.createStringMessageAttributes(_izContext, messageAttributes),
+        TopicArn: await snsSharedLib.snsTopicArn(_izContext, TOPIC_NAME_GENERATE_CODE.outUpdateNodeComplete),
+      };
+
+      _izContext.logger.debug("messageParams OutUpdateNodeComplete ::::::: ", messageParams);
+      await sns.publishAsync(_izContext, messageParams);
+
+      return updateNodeCompleteMessage
+    }
+
+    let awaitingStepIds = [];
+
+    // start update data
+    await Promise.all(
+      Object.entries(updateDataDetails).map(
+        async ([storageTag, updateDataDetail]) => {
+          if (updateDataDetail.storageType === consts.STORAGE_TYPES.graph) {
+            // let graphServiceName = await getGraphServiceTagWithCache(_izContext, getDataDetail.graphServiceTag)
+
+            awaitingStepIds.push( // createAwaitingstepId if updateGraph
+              asyncFlowSharedLib.createAwaitingStepId(
+                hash({
+                  objectType: OBJECT_TYPE,
+                  serviceTag: SERVICE_TAG,
+                  identifiers: identifiers,
+                  fields: fields,
+                  // correlationIds: _izContext.correlationIds.get("id")
+                }),
+                PREFIX.updateNode
+              )
+            )
+            _izContext.logger.debug("awaitingStepIds", awaitingStepIds)
+
+            if (awaitingStepIds.length) {
+              let awaitingMultipleStep = await asyncFlowSharedLib.createAwaitingMultipleSteps(
+                _izContext,
+                awaitingStepIds,
+                asyncFlowSharedLib.createPendingStepId(
+                  hash(
+                  {
+                    identifiers,
+                    fields,
+                  })
+                )
+              )
+              _izContext.logger.debug("awaitingMultipleStep", awaitingMultipleStep)
+            }
+
+            let updateNodeParams = {
+              objType: {
+                objectType: OBJECT_TYPE,
+                serviceTag: SERVICE_TAG
+              },
+              objInstanceFull: {
+                identifiers: identifiers,
+                fields: fields,
+              },
+              versionedDataIds: versionedDataIds,
+              originTimestamp
+            }
+
+            updateNodeParams = callingFlowSharedLib.addCallingFlowToSnsRequestMessageObject(
+              updateNodeParams,
+              callingFlowSharedLib.addParentCallingFlowConfig(
+                callingFlowConfig,
+                callingFlowSharedLib.createCallingFlowConfig(
+                  await lambdaSharedLib.lambdaFunctionName(_izContext, TOPIC_NAME_GENERATE_CODE.updateNodeComplete), {}
+                )
+              )
+            )
+
+            _izContext.logger.debug("messageObject before send message:", updateNodeParams);
+
+
+            let updateNodeMessageBody = {
+              Message: JSON.stringify(updateNodeParams),
+              MessageAttributes: sns.createStringMessageAttributes(_izContext, messageAttributes),
+              TopicArn: await snsSharedLib.snsTopicArn(_izContext, TOPIC_NAME_GRAPH_HANDLER.inUpdateNode, storageTag, )
+            }
+
+            _izContext.logger.debug('requset param before send to topic InUpdateNode:::', updateNodeMessageBody);
+
+            let resSNS = await sns.publishAsync(_izContext, updateNodeMessageBody)
+            _izContext.logger.debug('resSNS send to topic InUpdateNode finish!', resSNS);
+
+          } else if (updateDataDetail.storageType === consts.STORAGE_TYPES.dynamoDB) {
+
+            let identifiersForUpdateData = await dynamoDbIdentifiersByStorageResource(
+              _izContext,
+              objectSchema,
+              updateDataDetail,
+              identifiers
+            )
+
+            let fieldForUpdateTableDynamo = createFieldForUpdateDynamoDb(_izContext, objectSchema, updateDataDetail, fields)
+
+            _izContext.logger.debug("identifiersForUpdateData", identifiersForUpdateData)
+            _izContext.logger.debug("fieldForUpdateTableDynamo", fieldForUpdateTableDynamo)
+
+            let updateItem = await dynamodbSharedLib.updateItem(
+              _izContext,
+              await dynamodbSharedLib.tableName(_izContext, updateDataDetail.tableName),
+              identifiersForUpdateData,
+              fieldForUpdateTableDynamo,
+              {
+                returnValues: "ALL_NEW"
+              }
+            )
+            _izContext.logger.debug("updateItem:", updateItem);
+
+            if (awaitingStepIds.length == 0) {
+              let messageObject = {
+                objType: {
+                  objectType: OBJECT_TYPE,
+                  serviceTag: SERVICE_TAG
+                },
+                updateItem
+              }
+
+              if (callingFlowConfig[callingFlowSharedLib.consts.CALLINGFLOWPROPERTIES_PROPERTYNAME]) {
+                _izContext.logger.debug("HAVE CALLINGFLOW");
+
+                messageObject = callingFlowSharedLib.addPassBackPropertiesToSnsResponseMessageObject(callingFlowConfig, messageObject);
+                let messageAttributes = callingFlowSharedLib.addCallingFlowToSnsResponseMessageAttributes(callingFlowConfig, {});
+
+                _izContext.logger.debug("after create callingFlow", messageObject)
+                let outUpdateNodeCompleteTopic = await snsSharedLib.snsTopicArn(_izContext, TOPIC_NAME_GENERATE_CODE.outUpdateNodeComplete);
+                let messageParams = {
+                  Message: JSON.stringify(messageObject),
+                  MessageAttributes: sns.createStringMessageAttributes(_izContext, messageAttributes),
+                  TopicArn: outUpdateNodeCompleteTopic
+                }
+
+                _izContext.logger.debug("message params OutUpdateNodeComplete :::", messageParams);
+                await sns.publishAsync(_izContext, messageParams);
+
+              }
+            }
+          }
+        }
+      )
+    )
+    return {
+      returnValues: {
+        objType: {
+          objectType: OBJECT_TYPE,
+          serviceTag: SERVICE_TAG
+        },
+        objInstanceFull: {
+          identifiers: identifiers,
+          fields: fields,
+        },
+        versionedDataIds: versionedDataIds
+      },
+      status: "complete",
+      errorFounds
+    }
+  } catch (err) {
+    _izContext.logger.error('error AddressUpdate: ', err)
+    throw (err)
+  }
+}

package/src/reStructure/TemplateData/perActionEndpoint/yaml/api/data.js

@@ -0,0 +1,198 @@
+/*
+Copyright (C) 2020 Sven Mason <http://izara.io>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+'use strict';
+
+const path = require('path');
+
+const { ACTIONS, HANDLER, STORAGE_TYPES } = require('@izara_project/izara-core-library-service-schemas/src/Consts')
+
+// const { firstLetterLowerCase: lowerCase, firstLetterUpperCase: upperCase } = require("../#utils");
+// const { DEFAULT_HANDLER_PER_ACTION, createIamRole, resourceNames, RESOURCE_CLASSES, DEFAULT_LAMBDA_ROLE_PER_ACTION, SOURCE_PATH, SAVE_FILE_NAME, SNS_RESOURCE, FUNCTION_NAME, defaultIamRolePerAction, awaitingMultipleStepsRole, shortNameHandler } = require("../#const");
+const {
+  firstLetterLowerCase: lowerCase,
+  firstLetterUpperCase: upperCase,
+} = require("../../../../../MainLibs/index.js").utils;
+const {
+  DEFAULT_HANDLER_PER_ACTION,
+  createIamRole,
+  resourceNames,
+  RESOURCE_CLASSES,
+  DEFAULT_LAMBDA_ROLE_PER_ACTION,
+  SOURCE_PATH,
+  SAVE_FILE_NAME,
+  DYNAMO_RESOURCE,
+  SNS_RESOURCE,
+  FUNCTION_NAME,
+  defaultIamRolePerAction,
+  awaitingMultipleStepsRole,
+  shortNameHandler
+} = require("../../../../../MainLibs/index.js").consts;
+
+const templatePath = path.join(__dirname, "./template.ejs")
+
+/**
+ * receive objectSchema
+ * create data for hdrInv template
+ *
+ * @param {Object} objectSchema
+ * @return {{ templatePath, templateData, setting } }
+ */
+function data(_izContext, objectSchema, srcPath) {
+  let createSourceArray = [];
+  for (const action of Object.values(ACTIONS)) {
+    if (objectSchema.overWriteHandlers?.[action]) {
+      // if have overWriteHander of action check hdrApi inside
+      if (objectSchema.overWriteHandlers[action].includes(HANDLER.hdrApi)) {
+        // create template data
+        const createSourceParam = createParamForCreateSource(objectSchema, action, srcPath)
+        createSourceArray.push(createSourceParam)
+      }
+    } else {
+      // if not have overWriteHander of action will use default handler
+      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, srcPath)
+        createSourceArray.push(createSourceParam)
+      }
+    }
+  }
+  return createSourceArray;
+}
+
+function createParamForCreateSource(objectSchema, action, srcPath) {
+  // let objectType = objectSchema.objectType
+  let objectType = objectSchema.objectType;
+  let groupBy = objectSchema?.shortNameObjectType ? objectSchema.shortNameObjectType : objectSchema.objectType;
+  let functionName = upperCase(objectType) + upperCase(action);
+  let additionalResourcePermission = defaultIamRolePerAction();
+  let tableForGetItem = [];
+  let hasGraphStorage = false;
+  let functionNameObjectType = objectSchema?.shortNameObjectType ? objectSchema.shortNameObjectType : objectSchema.objectType
+  let functionNameConfig = upperCase(functionNameObjectType) + upperCase(action) + upperCase(shortNameHandler(HANDLER.hdrApi))
+
+  for (let storageResource of Object.values(objectSchema.storageResources)) {
+    if (storageResource.storageType === STORAGE_TYPES.dynamoDB) {
+      // add IamRole for dynamodb depend on tableName in storageResources of objectSchema
+      tableForGetItem.push(resourceNames(RESOURCE_CLASSES.dynamoDbTable, storageResource.tableName));
+
+    } else if (storageResource.storageType === STORAGE_TYPES.graph) {
+      // find graph serviceName from graphServerTag or *GetNodeHdrInv ?
+
+      if (hasGraphStorage) {
+        continue;
+      } else {
+        hasGraphStorage = true;
+      }
+    }
+  }
+
+  if (tableForGetItem.length) {
+    additionalResourcePermission.push(
+      createIamRole(
+        { [RESOURCE_CLASSES.dynamoDbTable]: [DEFAULT_LAMBDA_ROLE_PER_ACTION[action].dynamoDbPermission] },
+        tableForGetItem
+      )
+    );
+  }
+
+  function httpEvent(lambdaAction) {
+    return {
+      create: "put",
+      update: "post",
+      get: "post",
+      delete: "delete"
+    }[lambdaAction]
+  }
+
+  let event = httpEvent(action)
+  // console.log("event:", event)
+
+  if (action == ACTIONS.update) {
+    additionalResourcePermission.push(awaitingMultipleStepsRole())
+    additionalResourcePermission.push(
+      createIamRole(
+        {
+          [RESOURCE_CLASSES.sns]: [SNS_RESOURCE.publish]
+        },
+        [
+          resourceNames(RESOURCE_CLASSES.sns, "Out" + upperCase(FUNCTION_NAME.updateNodeComplete))
+        ]
+      )
+    )
+  } else if (action == ACTIONS.create) {
+    additionalResourcePermission.push(awaitingMultipleStepsRole());
+
+    additionalResourcePermission.push(
+      createIamRole(
+        {
+          [RESOURCE_CLASSES.sns]: [SNS_RESOURCE.publish]
+        },
+        [
+          resourceNames(RESOURCE_CLASSES.sns, "Out" + upperCase(FUNCTION_NAME.createObjectComplete))
+        ]
+      )
+    )
+  } else if (action == ACTIONS.delete) {
+    // additionalResourcePermission.push(
+    //   createIamRole(
+    //     {
+    //       [RESOURCE_CLASSES.sns]: [SNS_RESOURCE.publish]
+    //     },
+    //     [
+    //       resourceNames(RESOURCE_CLASSES.sns, "Out" + upperCase(FUNCTION_NAME.createObjectComplete))
+    //     ]
+    //   )
+    // )
+  } else if (action === ACTIONS.get) {
+    additionalResourcePermission.push(
+      createIamRole(
+        {
+          [RESOURCE_CLASSES.sns]: [SNS_RESOURCE.publish]
+        },
+        [
+          resourceNames(RESOURCE_CLASSES.sns, "OutGetNodeComplete")
+        ]
+      )
+    )
+  }
+
+  return {
+    templatePath: templatePath,
+    templateData: {
+      functionName: functionName,
+      resourceLocation: SOURCE_PATH.resourceLocationPerAction,
+      handlerType: upperCase(HANDLER.hdrApi),
+      additionalResourcePermission,
+      event: event,
+      objectType: objectType,
+      roleName: groupBy,
+      action: action,
+      functionNameConfig,
+    },
+    setting: {
+      savePath: path.join(srcPath, SOURCE_PATH.appYaml),
+      saveFileName: SAVE_FILE_NAME.functionPerActionYaml,
+      fileExtension: '.yml',
+      isAppend: true
+    }
+  }
+}
+
+
+module.exports = data;

package/src/reStructure/TemplateData/perActionEndpoint/yaml/api/request.json

@@ -0,0 +1,14 @@
+{
+  "funcitonName": "xx",
+  "handler": "hdrApi",
+  "iamRoleStatement": {
+    "Effect": "Allow",
+    "Action": {
+      "xxx": [
+        "yyy",
+        "xxx"
+      ]
+    },
+    "Resource": "xxxxx"
+  }
+}

package/src/reStructure/TemplateData/perActionEndpoint/yaml/api/template.ejs

@@ -0,0 +1,20 @@
+<%_ const join = require('path').join; _%>
+<%- firstLetterUpperCase(functionNameConfig) %>:
+  handler: <%- join(resourceLocation, `${firstLetterUpperCase(functionName)}_${firstLetterUpperCase(handlerType)}.main`)%>
+  name: ${self:custom.iz_resourcePrefix}<%- firstLetterUpperCase(functionName) %><%- firstLetterUpperCase(handlerType) %>
+  events:
+    - http:
+        path: <%- firstLetterUpperCase(objectType) %>/<%- firstLetterUpperCase(action) %>
+        method: <%- event %>
+        cors: true
+        #<#<%- firstLetterUpperCase(functionName) %><%- firstLetterUpperCase(handlerType) %>Authorizer#>
+        #<#/<%- firstLetterUpperCase(functionName) %><%- firstLetterUpperCase(handlerType) %>Authorizer#>
+  role: <%- firstLetterUpperCase(roleName) %>Role
+    #<#<%- functionName %><%- handlerType %>IamRole#>
+    #<#/<%- functionName %><%- handlerType %>IamRole#>
+<%_ function firstLetterUpperCase(text){
+  return text.charAt(0).toUpperCase() + text.slice(1)
+} _%>
+<%_ function firstLetterLowerCase(str) {
+  return str.charAt(0).toLowerCase() + str.slice(1)
+} _%>