@izara_project/izara-market-library-service-schemas 1.0.29 → 1.0.31

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

@@ -0,0 +1,330 @@
+/*
+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 dynamodbSharedLib = require('@izara_project/izara-core-library-dynamodb');
+const snsSharedLib = require('@izara_project/izara-core-library-sns');
+const asyncFlowSharedLib = require('@izara_project/izara-core-library-asynchronous-flow');
+const callingFlowSharedLib = require('@izara_project/izara-core-library-calling-flow');
+const lambdaSharedLib = require('@izara_project/izara-core-library-lambda');
+
+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')
+const { createObjType } = require("@izara_project/izara-core-library-service-schemas/src/Utils")
+/**
+ *
+ *
+ * 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.updateMain = async (
+  _izContext,
+  requestParams,
+  callingFlowConfig = {},
+  //(<additionalParams>)
+  //(</additionalParams>)
+) => {
+
+  try {
+    _izContext.logger.debug('function UpdateMain: ', {
+      requestParams,
+      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")
+    }
+
+    //(<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
+    })
+    const objType = createObjType(requestParams.objectType);
+    let objectSchema = await getObjSchemaS3WithHierarchy(
+      _izContext,
+      objType
+    )
+    _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: objType,
+        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.snsTopicArnByFlowSchema(_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: objType.objectType,
+                  serviceTag: objType.serviceTag,
+                  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: objType,
+              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: objType,
+                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.snsTopicArnByFlowSchema(_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: objType,
+        objInstanceFull: {
+          identifiers: identifiers,
+          fields: fields,
+        },
+        versionedDataIds: versionedDataIds
+      },
+      status: "complete",
+      errorFounds
+    }
+  } catch (err) {
+    _izContext.logger.error('error AddressUpdate: ', err)
+    throw (err)
+  }
+}

package/src/reStructure/TemplateData/EndpointPerService/yaml/data.js

@@ -0,0 +1,177 @@
+/*
+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("../../../../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,
+  SOURCE_GENERATE_IAM_ROLE,
+  getStorageResourceFromObjectSchemas,
+  SQS_RESOURCE
+} = require("../../../../MainLibs/src/Consts.js");
+
+const templatePath = path.join(__dirname, "./template.ejs")
+
+/**
+ * receive objectSchema
+ * create data for hdrInv template
+ *
+ * @param {Object} objectSchema
+ * @return {{ templatePath, templateData, setting } }
+ */
+async function data(_izContext, allObjSchemas, srcPath) {
+  let createSourceSet = new Set();
+  for (const action of Object.values(ACTIONS)) {
+    const defaultHandlers = DEFAULT_HANDLER_PER_ACTION[action]
+    for (const defaultHandler of defaultHandlers) {
+      const createSourceParam = await createParamForCreateSource(_izContext, allObjSchemas, action, defaultHandler, srcPath)
+      createSourceParam && createSourceSet.add(createSourceParam)
+    }
+  }
+  return [...createSourceSet];
+}
+
+async function createParamForCreateSource(_izContext, allObjSchemas, action, handler, srcPath) {
+  let groupBy = SOURCE_GENERATE_IAM_ROLE.perActionEndpoint;
+  let additionalResourcePermission = defaultIamRolePerAction();
+  let functionNameConfig = upperCase(action) + upperCase(shortNameHandler(handler))
+
+  let storageResourceAllLocalObjectSchemas = await getStorageResourceFromObjectSchemas(_izContext, allObjSchemas)
+
+  if (storageResourceAllLocalObjectSchemas.resourceDynamoTableName.length) {
+    additionalResourcePermission.push(
+      createIamRole(
+        {
+          [RESOURCE_CLASSES.dynamoDbTable]: Object.values(DYNAMO_RESOURCE),
+        },
+        storageResourceAllLocalObjectSchemas.resourceDynamoTableName.map(tableName =>
+          resourceNames(RESOURCE_CLASSES.dynamoDbTable, tableName)
+        )
+      )
+    )
+  }
+
+  function httpEvent(lambdaAction) {
+    return {
+      create: "put",
+      update: "post",
+      get: "post",
+      delete: "delete"
+    }[lambdaAction]
+  }
+
+  function sqsEvent(handler) {
+    return {
+      [HANDLER.hdrSqs]: resourceNames(RESOURCE_CLASSES.sqs, upperCase(action) + upperCase(HANDLER.hdrSqs)),
+      [HANDLER.hdrDsq]: resourceNames(RESOURCE_CLASSES.sqs, upperCase(action) + upperCase(HANDLER.hdrDsq))
+    }[handler]
+  }
+
+  let event;
+  if (handler === HANDLER.hdrApi) {
+    event = httpEvent(action)
+  } else if (handler === HANDLER.hdrDsq || handler === HANDLER.hdrSqs) {
+    event = sqsEvent(handler)
+  }
+
+  additionalResourcePermission.push(awaitingMultipleStepsRole());
+
+  additionalResourcePermission.push(
+    createIamRole(
+      { [RESOURCE_CLASSES.sns]: SNS_RESOURCE.publish },
+      [
+        resourceNames(RESOURCE_CLASSES.sns, upperCase(FUNCTION_NAME.createObjectComplete) + "_Out")
+      ]
+    ),
+
+    createIamRole(
+      { [RESOURCE_CLASSES.sns]: SNS_RESOURCE.publish },
+      [
+        resourceNames(RESOURCE_CLASSES.sns, upperCase(FUNCTION_NAME.updateNodeComplete) + "_Out")
+      ]
+    ),
+    createIamRole(
+      { [RESOURCE_CLASSES.sns]: SNS_RESOURCE.publish },
+      [
+        resourceNames(RESOURCE_CLASSES.sns, upperCase(FUNCTION_NAME.deleteNodeComplete) + "_Out")
+      ]
+    ),
+    createIamRole(
+      {
+        [RESOURCE_CLASSES.sns]: SNS_RESOURCE.publish
+      },
+      [
+        resourceNames(RESOURCE_CLASSES.sns, upperCase(FUNCTION_NAME.getNodeComplete) + "_Out")
+      ]
+    )
+  )
+
+  if (handler === HANDLER.hdrSqs) {
+    additionalResourcePermission.push(
+      createIamRole({
+        [RESOURCE_CLASSES.sqs]: [SQS_RESOURCE.receiveMessage, SQS_RESOURCE.sendMessage, SQS_RESOURCE.deleteMessage, SQS_RESOURCE.getQueueAttributes]
+      },
+        [
+          resourceNames(RESOURCE_CLASSES.sqs, upperCase(action) + upperCase(handler)),
+          resourceNames(RESOURCE_CLASSES.sqs, upperCase(action) + upperCase(handler) + "DLQ")
+        ]
+      )
+    )
+  }
+
+  return {
+    templatePath: templatePath,
+    templateData: {
+      resourceLocation: SOURCE_PATH.resourceLocationHandlerEndpointPerService,
+      handlerType: handler,
+      additionalResourcePermission,
+      event: event,
+      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/EndpointPerService/yaml/template.ejs

@@ -0,0 +1,26 @@
+<%_ const join = require('path').join _%>
+<%- firstLetterUpperCase(functionNameConfig) %>:
+  handler: <%- join(resourceLocation, `${firstLetterUpperCase(action)}_${firstLetterUpperCase(handlerType)}.main`) %>
+  name: ${self:custom.iz_resourcePrefix}<%- firstLetterUpperCase(action) %><%- firstLetterUpperCase(handlerType) %>
+  events:
+  <%_ if (handlerType === "hdrDsq" || handlerType === "hdrSqs") { _%>
+    - sqs:
+        arn: <%- event %>
+        batchSize: 10
+  <%_ } else if (handlerType === "hdrApi") { _%>
+    - http:
+        path: <%- firstLetterUpperCase(action) %>
+        method: <%- event %>
+        cors: true
+        #<#<%- firstLetterUpperCase(action) _%><%- firstLetterUpperCase(handlerType) %>Authorizer#>
+        #<#/<%- firstLetterUpperCase(action) _%><%- firstLetterUpperCase(handlerType) %>Authorizer#>
+  <%_ } _%>
+  role: <%- firstLetterUpperCase(roleName) _%>Role
+    #<#<%_ action _%><%_ handlerType _%>IamRole#>
+    #<#/<%_ action _%><%_ handlerType _%>IamRole#>
+<%_ function firstLetterUpperCase(text){
+  return text.charAt(0).toUpperCase() + text.slice(1)
+} _%>
+<%_ function firstLetterLowerCase(str) {
+  return str.charAt(0).toLowerCase() + str.slice(1)
+} _%>

package/src/reStructure/TemplateData/externalService/generateTemplateData.js

@@ -44,7 +44,7 @@ async function generateCodeWithTemplate(_izContext, objSchemaPath) {
     const allObjectRelationships = getAllLocalRelationshipSchema(_izContext, objSchemaPath);
     const allLocalFlowSchemas = await getAllLocalFlowSchemas(_izContext, objSchemaPath);
     // create External service
-    const createFunctionIamRole = await createExternalLambdaRole(_izContext, allObjSchemas.records, allObjectRelationships, allLocalFlowSchemas.records, saveFilePath);
+    const createFunctionIamRole = await createExternalLambdaRole(_izContext, allObjSchemas, allObjectRelationships, allLocalFlowSchemas.records, saveFilePath);
     const createSnsSubscription = await createExternalSnsSubscriptions(_izContext, allObjSchemas.records, allObjectRelationships, allLocalFlowSchemas.records, saveFilePath);
 
     createSourceParams.push(createFunctionIamRole, createSnsSubscription);