@izara_project/izara-market-library-service-schemas 1.0.7 → 1.0.8

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

@@ -55,8 +55,8 @@ const PREFIX = {
   CREATE_OBJECT_ASYNC_COMPLETE: "createObjectAsyncComplete"
 }
 //-----------------------------------------------------------------------------------------------------------
-
-const { createCreateDataDetailsV2 } = require('@izara_project/izara-market-library-service-schemas/src/GenerateCodeLibs/src/GenerateCodeLibs')
+const { TOPIC_NAME_GENERATE_CODE, TOPIC_NAME_GRAPH_HANDLER, GRAPH_HANDLER_SERVICE_NAME } = require('@izara_project/izara-market-library-service-schemas/src/GenerateCodeLibs/src/Consts')
+const { createDataDetailsLib } = require('@izara_project/izara-market-library-service-schemas/src/GenerateCodeLibs/src/GenerateCodeLibs')
 const { createLinkTypeId } = require('@izara_project/izara-core-library-service-schemas/src/Utils');
 
 /**
@@ -92,13 +92,18 @@ module.exports.<%- functionName %>Main = async (
       callingFlowConfig
     });
 
+    let errorsFound = [];
+
     _izContext.correlationIds.set(coreConsts.BASE_USER_ID, "BasDev");
+    const userId = _izContext.correlationIds.get(coreConsts.BASE_USER_ID);
+    if (!userId) {
+      errorsFound.push("Not have userId")
+    }
 
     const OBJECT_TYPE = "<%- objectType %>";
     const SERVICE_TAG = process.env.iz_serviceTag;
     //(<beforeQuery>)
     //(</beforeQuery>)
-
     const MAIN_OBJTYPE = {
       objectType: OBJECT_TYPE,
       serviceTag: SERVICE_TAG
@@ -110,21 +115,19 @@ module.exports.<%- functionName %>Main = async (
     );
     _izContext.logger.debug("objectSchema", objectSchema);
 
-    let objectSchemas = uploadUseCase.generateObjectSchemaForGraphHandler(
+    let objectSchemas = uploadUseCase.generateObjectSchemaForCombineFieldNames(
       _izContext,
       objectSchema
     );
     _izContext.logger.debug("objectSchemas", objectSchemas);
 
-    let createDataDetails = await createCreateDataDetailsV2(_izContext, objectSchemas);
+    let createDataDetails = await createDataDetailsLib(_izContext, objectSchemas);
     _izContext.logger.debug("createDataDetails is =", createDataDetails);
 
-    let errorsFound = [];
-
     //validate linkType
-    if ((requestParams.hasOwnProperty("relationships")) && (requestParams.relationship.length > 0)) {
+    if ((requestParams.hasOwnProperty("relationships")) && (requestParams.relationships.length > 0)) {
 
-      for (let relationshipProperties of requestParams.relationship) {
+      for (let relationshipProperties of requestParams.relationships) {
         _izContext.logger.debug("relType", relationshipProperties.relType)
         let getObjectRelationship = await getObjectSchema.getRelationshipSchemaWithCache(
           _izContext,
@@ -142,132 +145,100 @@ module.exports.<%- functionName %>Main = async (
       }
     }
 
-    // validate relationship link
-    let requiredOnCreateLinks = await getObjectSchema.getRequiredOnCreateLinksGraphHandlerWithCache(_izContext, MAIN_OBJTYPE);
-    _izContext.logger.debug("requiredOnCreateLinks", requiredOnCreateLinks);
-
-    let filterRequireOnCreateRels = {};
+    let requiredOnCreateLinks = {};
+    let createLinkTypeIds = [];
+    // validate relationships link
+    let objectRelationshipSchema = await getObjectSchema.getRequiredOnCreateLinksWithCache(_izContext, MAIN_OBJTYPE);
+    _izContext.logger.debug("objectRelationshipSchema", objectRelationshipSchema);
 
-    for (const [relationshipTag, relationshipProperties] of Object.entries(requiredOnCreateLinks)) {
-      let filterRequiredLinks = [];
+    let filteredRequiredOnCreatedLinks = [];
 
-      for (const link of relationshipProperties.links) {
-        _izContext.logger.debug("linkObjectRelationship", link)
-        const serviceTags = await Promise.all(
-          link.storageResourceTags.map(async (storageTag) => {
-            let storageResource = relationshipProperties.storageResources[storageTag];
+    await Promise.all(
+      objectRelationshipSchema.map(async (requiredLink) => {
+        const serviceTag = await Promise.all(
+          requiredLink.storageResourceTags.map(async (storageTag) => {
+            let storageResource = requiredLink.storageResources[storageTag];
             if (storageResource.storageType === consts.STORAGE_TYPES.graph) {
-              return await getGraphServiceTagWithCache(_izContext, storageResource.graphServerTag)
+              return await getGraphServiceTagWithCache(_izContext, storageResource.graphServerTag);
             }
           })
-        )
-        _izContext.logger.debug('serviceTags: ', serviceTags);
-
-        if (serviceTags.includes("GraphHandler")) {
-          filterRequiredLinks.push(link)
+        );
+        if (serviceTag.includes(GRAPH_HANDLER_SERVICE_NAME.graphHandler)) {
+          filteredRequiredOnCreatedLinks.push(requiredLink);
         }
-      }
-
-      if (filterRequiredLinks.length) {
-        Object.assign(filterRequireOnCreateRels,
-          {
-            [relationshipTag]: {
-              ...relationshipProperties,
-              links: filterRequiredLinks
-            }
-          })
-      }
-    }
-    _izContext.logger.debug("filterRequireOnCreateRels", filterRequireOnCreateRels)
-
-    if (Object.keys(filterRequireOnCreateRels).length) {
-      if (!requestParams.relationship.length) {
-        for (const relTag in filterRequireOnCreateRels) {
-          errorsFound.push(`missing required relationship of relType: serviceTag: ${filterRequireOnCreateRels[relTag].relationshipServiceTag}, relationshipTag: ${relTag} when create`);
+      })
+    )
+    _izContext.logger.debug("filteredRequiredOnCreatedLinks", filteredRequiredOnCreatedLinks);
+
+    if (filteredRequiredOnCreatedLinks.length) {
+      if (!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`)
         }
       }
 
-      let requiredOnCreateLinks = {};
-      let createLinkTypeIds = [];
-
-      for (const [relTag, relationshipProperties] of Object.entries(filterRequireOnCreateRels)) {
-        _izContext.logger.debug("relationshipProperties", relationshipProperties);
-
-        for (const link of relationshipProperties.links) {
-          const requiredOnCreateLinkTypeId = createLinkTypeId(
-            _izContext,
-            [link.from.objType, link.to.objType],
-            {
-              relationshipTag: relTag,
-              serviceTag: relationshipProperties.relationshipServiceTag
-            }
-          )
-
-          Object.assign(requiredOnCreateLinks,
-            {
-              [requiredOnCreateLinkTypeId]: {
-                relType: {
-                  relationshipTag: relTag,
-                  serviceTag: relationshipProperties.relationshipServiceTag
-                },
-                link: link
-              }
-            })
-          _izContext.logger.debug("requiredOnCreateLinks", requiredOnCreateLinks)
-        }
+      for (const requireLink of filteredRequiredOnCreatedLinks) {
+        const requiredOnCreateLinkTypeId = createLinkTypeId(
+          _izContext,
+          [
+            MAIN_OBJTYPE, requireLink.other.objType
+          ],
+          requireLink.relType
+        );
+
+        Object.assign(requiredOnCreateLinks, {
+          [requiredOnCreateLinkTypeId]: requireLink
+        })
       }
 
-      for (const createRelationship of requestParams.relationship) {
+      for (const createRelationship of requestParams.relationships) {
         const onCreateLinkTypeId = createLinkTypeId(
           _izContext,
-          [MAIN_OBJTYPE, createRelationship.targetObjType],
+          [
+            MAIN_OBJTYPE, createRelationship.targetObjType
+          ],
           createRelationship.relType
-        )
+        );
 
         if (!requiredOnCreateLinks.hasOwnProperty(onCreateLinkTypeId)) {
-          errorsFound.push(`relType:${JSON.stringify(createRelationship.relType)} are not relationshipSchema for this objType`)
+          errorsFound.push(`relType:${JSON.stringify(createRelationship.relType)} not allow to create when use create action`)
           continue;
         } else {
-          createLinkTypeIds.push(onCreateLinkTypeId)
-        }
-        // validate missing relType that should create
-        const remainRequiredOnCreateLinkTypeIds = Object.keys(requiredOnCreateLinks)
-          .filter(requiredOnCreateLinkTypeId => !createLinkTypeIds.includes(requiredOnCreateLinkTypeId));
-
-        if (remainRequiredOnCreateLinkTypeIds.length) {
-          for (const remainRequiredOnCreateLinkTypeId of remainRequiredOnCreateLinkTypeIds) {
-            const missingLink = {
-              from: requiredOnCreateLinks[remainRequiredOnCreateLinkTypeId].link.from,
-              to: requiredOnCreateLinks[remainRequiredOnCreateLinkTypeId].link.to,
-            };
-            errorsFound.push(`Missing link:${JSON.stringify(missingLink)} when create`);
-          }
+          createLinkTypeIds.push(onCreateLinkTypeId);
         }
-
-        _izContext.logger.debug("requiredOnCreateLinks: ", requiredOnCreateLinks);
-        _izContext.logger.debug("onCreateLinkTypeIds: ", createLinkTypeIds);
-
       }
-    } else {
+    }
+
+    // validate missing relType when create that should create
+    const remainRequiredOnCreateLinkTypeIds = Object.keys(requiredOnCreateLinks)
+      .filter(requiredInCreateLinkTypeId => !createLinkTypeIds.includes(requiredInCreateLinkTypeId))
 
-      if (requestParams.relationships.length) {
-        errorsFound.push(`objType:${JSON.stringify(objType)} not need relationships when create`);
+    if (remainRequiredOnCreateLinkTypeIds.length) {
+      for (const remainRequiredOnCreateLinkTypeId of remainRequiredOnCreateLinkTypeIds) {
+        const missingLink = {
+          relType: requiredOnCreateLinks[remainRequiredOnCreateLinkTypeId].relType,
+          base: requiredOnCreateLinks[remainRequiredOnCreateLinkTypeId].base.objType,
+          other: requiredOnCreateLinks[remainRequiredOnCreateLinkTypeId].other.objType
+        };
+        errorsFound.push(`Missing Link:: ${JSON.stringify(missingLink)} when create`)
       }
     }
+    _izContext.logger.debug("createLinkTypeIds", createLinkTypeIds);
+    _izContext.logger.debug("requiredOnCreateLinks", requiredOnCreateLinks);
 
     let objInstanceFull = {
       identifiers: {},
       fields: {}
     };
 
-    let listOfRequriedOnCreate = [];
+    let listOfRequiredOnCreate = [];
     let listOfOptionalOnCreate = [];
 
     let allAwaitingStepsId = [];
 
-
     // validate single identifiers
-    if (objectSchemas.identifiers.length === 1 && !identifier.hasOwnProperty("fieldNames")) {
+    if (objectSchemas.identifiers.length === 1 && !objectSchemas.identifiers.hasOwnProperty("fieldNames")) {
 
       const identifier = objectSchemas.identifiers[0];
       _izContext.logger.debug(":::::case single identifer:::::", identifier);
@@ -320,17 +291,15 @@ module.exports.<%- functionName %>Main = async (
 
     _izContext.logger.debug("requestParams is:", requestParams);
 
-
-
     // check settingObjSchemas
     for (let [keyFieldNames, valueFieldNames] of Object.entries(objectSchemas.fieldNames)) {
 
       if (valueFieldNames.hasOwnProperty("randomOnCreate") && valueFieldNames.randomOnCreate === true) {
-        listOfRequriedOnCreate.push(keyFieldNames)
+        listOfRequiredOnCreate.push(keyFieldNames)
       };
 
       if (valueFieldNames.hasOwnProperty("requiredOnCreate") && valueFieldNames.requiredOnCreate === true) {
-        listOfRequriedOnCreate.push(keyFieldNames)
+        listOfRequiredOnCreate.push(keyFieldNames)
       };
 
       if (valueFieldNames.hasOwnProperty("optionalOnCreate") && valueFieldNames.optionalOnCreate === true) {
@@ -339,35 +308,29 @@ module.exports.<%- functionName %>Main = async (
         };
       };
 
-
     }; // end iteration of fieldNames
 
-    _izContext.logger.debug("listOfRequriedOnCreate", listOfRequriedOnCreate);
+    _izContext.logger.debug("listOfRequriedOnCreate", listOfRequiredOnCreate);
     _izContext.logger.debug("listOfOptionalOnCreate", listOfOptionalOnCreate);
-    for (let fieldName of Object.keys(requestParams.objInstanceFull.fieldNames)) {
+    for (let fieldName of Object.keys(requestParams.fieldNames)) {
 
-      if (!listOfRequriedOnCreate.includes(fieldName)) {
+      if (!listOfRequiredOnCreate.includes(fieldName)) {
         if (!listOfOptionalOnCreate.includes(fieldName)) {
           errorsFound.push("[invalid] over fieldNames create object");
         }
       };
 
-      if (listOfOptionalOnCreate.length > 0 && listOfRequriedOnCreate.includes(fieldName)) {
-        // HookCode
-        // HookCode
+      if (listOfOptionalOnCreate.length > 0 && listOfRequiredOnCreate.includes(fieldName)) {
+        //(<optionalParams>)
+        //(</optionalParams>)
       };
 
-      /*
-        fix version if change objInstance initial
-        can delete condition if (listOfRequriedOnCreate.includes(fieldName))
-      */
-
-      // if (objectSchemas.identifierFieldNames.includes(fieldName)) {
-      //   _izContext.logger.debug("identifiers is", fieldName);
-      //   Object.assign(objInstance.identifiers, {
-      //     [fieldName]: requestParams.fieldNames[fieldName]
-      //   });
-      // };
+      if (objectSchemas.identifierFieldNames.includes(fieldName)) {
+        _izContext.logger.debug("identifiers is", fieldName);
+        Object.assign(objInstanceFull.identifiers, {
+          [fieldName]: requestParams.fieldNames[fieldName]
+        });
+      };
 
       if (errorsFound.length > 0) {
         _izContext.logger.debug("HaveError::", errorsFound);
@@ -379,35 +342,38 @@ module.exports.<%- functionName %>Main = async (
     let listOfObjectForCreates = [];
     if (errorsFound.length == 0) {
 
-      for (let [serviceName, createDataDetail] of Object.entries(createDataDetails)) {
+      for (let [storageTag, createDataDetail] of Object.entries(createDataDetails)) {
 
-        for (let fieldNames of Object.keys(requestParams.objInstanceFull.fieldNames)) {
+        for (let fieldName of Object.keys(requestParams.fieldNames)) {
 
-          if (createDataDetail.fieldNames.includes(fieldNames) && listOfRequriedOnCreate.includes(fieldNames)) {
-            _izContext.logger.debug("fieldNames match in detail is:", fieldNames);
-
-            if (objInstanceFull.hasOwnProperty("fields")) {
-              Object.assign(objInstanceFull.fields, {
-                [fieldNames]: requestParams.objInstanceFull.fieldNames[fieldNames]
-              })
-            } else {
-              Object.assign(objInstanceFull, {
-                fields: {
-                  [fieldNames]: requestParams.objInstanceFull.fieldNames[fieldNames]
-                }
-              })
-            };
+          if (createDataDetail.fieldNames.includes(fieldName) &&
+            listOfOptionalOnCreate.includes(fieldName) || listOfRequiredOnCreate.includes(fieldName)
+          ) {
+            _izContext.logger.debug("fieldNames match in detail is:", fieldName);
+
+            if (!objInstanceFull.identifiers.hasOwnProperty(fieldName))
+              if (objInstanceFull.hasOwnProperty("fields")) {
+                Object.assign(objInstanceFull.fields, {
+                  [fieldName]: requestParams.fieldNames[fieldName]
+                })
+              } else {
+                Object.assign(objInstanceFull, {
+                  fields: {
+                    [fieldName]: requestParams.fieldNames[fieldName]
+                  }
+                })
+              };
           };
         };
-        _izContext.logger.debug("objInstanceFull", objInstanceFull)
+
         if (createDataDetail.storageType == consts.STORAGE_TYPES.dynamoDB) {
-          _izContext.logger.debug("::::::DynamoDB::::::", { serviceName, objInstanceFull });
+          _izContext.logger.debug("::::::DynamoDB::::::", { storageTag, objInstanceFull });
 
           let identifiersForCreateData = await dynamoDbIdentifiersByStorageResource(
             _izContext,
             objectSchema,
             createDataDetails,
-            requestParams.objInstanceFull.fieldNames
+            objInstanceFull.identifiers
           )
           _izContext.logger.debug("identifiersForCreateData", identifiersForCreateData);
 
@@ -417,24 +383,26 @@ module.exports.<%- functionName %>Main = async (
               _izContext,
               createDataDetail.tableName
             ),
-            identifiersForCreateData
+            {
+              ...identifiersForCreateData,
+              ...objInstanceFull.fields
+            }
           );
 
-
         } else if (createDataDetail.storageType == consts.STORAGE_TYPES.graph) {
-          _izContext.logger.debug("::::::Graphanler::::::", { serviceName, objInstanceFull });
+          _izContext.logger.debug("::::::Graphanler::::::", { storageTag, objInstanceFull });
 
           // allStorageTagComplete = false;
           allAwaitingStepsId.push(asyncFlowSharedLib.createAwaitingStepId(
             (hash({
               objType: MAIN_OBJTYPE,
-              graphServerTag: serviceName,
+              graphServerTag: storageTag,
               identifiers: objInstanceFull.identifiers
             })),
             PREFIX.CREATE_OBJECT_ASYNC
           ));
           listOfObjectForCreates.push({
-            [serviceName]: {
+            [storageTag]: {
               objInstanceFull: {
                 identifiers: objInstanceFull.identifiers,
                 fields: objInstanceFull.fields
@@ -475,6 +443,7 @@ module.exports.<%- functionName %>Main = async (
           messageObject = {
             objType: MAIN_OBJTYPE,
             objInstanceFull: objecForCreate.objInstanceFull,
+            relationships: requestParams.relationships
           };
         };
 
@@ -488,25 +457,19 @@ module.exports.<%- functionName %>Main = async (
             originTimestamp: Date.now()
           });
 
-          // seagame: not need to check callingFlow before send to graph, Just add callingFlow and parent callingFlow before send to graph
-          if (callingFlowConfig[callingFlowSharedLib.consts.CALLINGFLOW_PROPERTYNAME]) {
-            _izContext.logger.debug("Have callingFlow", callingFlowConfig);
-            _izContext.logger.debug("callingFlowProperties", callingFlowConfig[callingFlowSharedLib.consts.CALLINGFLOWPROPERTIES_PROPERTYNAME])
-
-            messageObject = callingFlowSharedLib.addCallingFlowToSnsRequestMessageObject(
-              messageObject,
-              callingFlowSharedLib.addParentCallingFlowConfig(
-                callingFlowConfig, // resive parent callingFlowConfig.
-                callingFlowSharedLib.createCallingFlowConfig( // callinfflow own service
-                  await lambdaSharedLib.lambdaFunctionName(_izContext, "CreateObjectCompleteHdrSqs"),
-                )
+          messageObject = callingFlowSharedLib.addCallingFlowToSnsRequestMessageObject(
+            messageObject,
+            callingFlowSharedLib.addParentCallingFlowConfig(
+              callingFlowConfig, // resive parent callingFlowConfig.
+              callingFlowSharedLib.createCallingFlowConfig( // callinfflow own service
+                await lambdaSharedLib.lambdaFunctionName(_izContext, TOPIC_NAME_GENERATE_CODE.createNodeComplete), {}
               )
-            );
-          };
+            )
+          );
 
           let messageToCreateObject = {
             Message: JSON.stringify(messageObject),
-            TopicArn: await snsSharedLib.snsTopicArn(_izContext, "InCreateNodeV2", graphServiceName)
+            TopicArn: await snsSharedLib.snsTopicArn(_izContext, TOPIC_NAME_GRAPH_HANDLER.inCreateNode, graphServiceName)
           };
           _izContext.logger.debug("RequestParams before send to sqs messageToCreateObject ::::::: ", messageToCreateObject);
           await sns.publishAsync(_izContext, messageToCreateObject);
@@ -543,33 +506,28 @@ module.exports.<%- functionName %>Main = async (
       let sendMessageOutCreateObjectComplete = {
         Message: JSON.stringify(messageObject),
         MessageAttributes: sns.createStringMessageAttributes(_izContext, messageAttributes),
-        TopicArn: await snsSharedLib.snsTopicArn(_izContext, "OutCreateObjectComplete")
+        TopicArn: await snsSharedLib.snsTopicArn(_izContext, TOPIC_NAME_GENERATE_CODE.outCreateNodeComplete)
       };
       _izContext.logger.debug("Send message to OutCreateObjectComplete :::>", sendMessageOutCreateObjectComplete)
       await sns.publishAsync(_izContext, sendMessageOutCreateObjectComplete);
 
-      return { returnValue: "function DeliveryMetodStandate have errorFounds" }
+      return {
+        objType: MAIN_OBJTYPE,
+        fieldNames: requestParams.fieldNames,
+        relationship: requestParams.relationships,
+        status: "error",
+        errorsFound: errorsFound
+      }
+    } else {
+      return {
+        objType: MAIN_OBJTYPE,
+        fieldNames: requestParams.fieldNames,
+        relationship: requestParams.relationships,
+        status: "complete",
+      }
     }
-    _izContext.logger.debug("end errorsFound is:", errorsFound);
 
   } catch (err) {
     throw (err)
   }
-
-}
-
-/*
-example return
-* identifierFieldNames will not includes inside fieldNames of createObjectDetails
-{
-  dynamoDBStorageTag:{
-    storageType:"dynamoDB",
-    tableName:"xxx",
-    fieldNames:[...fieldName]
-  },
-  GraphServiceTag:{
-    storageType: 'graph',
-    fieldNames: [ 'bookId2', 'bookName' ]
-  }
-}
-*/
+}

package/src/TemplateManager/src/PerActionEndpoint/MainFunction/Delete/data.js

@@ -0,0 +1,66 @@
+/*
+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 fs = require('fs');
+
+const { ACTIONS, HANDLER } = require('@izara_project/izara-core-library-service-schemas/src/Consts')
+const { firstLetterLowerCase: lowerCase, firstLetterUpperCase: upperCase, firstLetterUpperCase } = require("../../../../../MainLibs/src/Utils")
+const { DEFAULT_HANDLER_PER_ACTION, SOURCE_PATH } = require("../../../libs/Consts");
+
+
+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, objectSchema, srcPath) {
+  if (objectSchema.overwriteGeneratedMainFunction?.length
+    && objectSchema.overwriteGeneratedMainFunction.includes(ACTIONS.delete)
+  ) {
+    return [];
+  } else {
+    return [await createParamForCreateSource(_izContext, objectSchema, ACTIONS.delete, srcPath)]
+  }
+}
+
+async function createParamForCreateSource(_izContext, objectSchema, action, srcPath) {
+  let objectType = objectSchema.objectType;
+  let functionName = objectType + upperCase(action);
+  return {
+    templatePath: templatePath,
+    templateData: {
+      functionName: functionName,
+      objectType: objectType,
+      action: action
+    },
+    setting: {
+      savePath: path.join(srcPath, SOURCE_PATH.lambdaPerAction),
+      saveFileName: `${upperCase(objectSchema.objectType)}${upperCase(action)}_Main`,
+      fileExtension: '.js',
+      isAppend: false
+    }
+  }
+}
+
+
+module.exports = data;