@izara_project/izara-core-generate-service-code 1.0.68 → 1.0.70

package/src/emit/shared/templates/ProcessLogical_Main.ejs

@@ -0,0 +1,448 @@
+/*
+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/>.
+*/
+
+import dynamodbSharedLib from '@izara_project/izara-core-library-dynamodb';
+import snsSharedLib from '@izara_project/izara-core-library-sns';
+import logicalResultsSharedLib from '@izara_project/izara-core-library-logical-result';
+import searchResultSharedLib from '@izara_project/izara-core-library-search-result';
+import { sns } from '@izara_project/izara-core-library-external-request';
+
+import {
+  getObjectSchema,
+  serviceConfig,
+  consts,
+  utils
+} from '@izara_project/izara-core-library-service-schemas';
+import { NoRetryError } from '@izara_project/izara-core-library-core';
+const { STORAGE_TYPES } = consts;
+const { getUsedFieldNamesOfIdentifiers } = utils;
+
+//(<additionalModule>)
+import { identifiersObject as identifierObj } from '@izara_project/izara-core-library-service-schemas';
+//(</additionalModule>)
+
+/**
+ * performs the logical operation/filter/search in the element, saves into LogicalResultsData table
+ * @param {Object} _izContext
+ * @param {Object} objType - contain objectType and serviceTag
+ * @param {Object} element - logical element
+ * @param {Object} element.filterType - 'logical'
+ * @param {string} element.logicalType - contain 'identifier' | 'partitionKey'
+ * @param {Object} [element.partitionKeyValues] - value of fieldNames that is partitionKey.
+ * @param {Object} [element.sortKeyValues] - value of fieldNames that is sortKey. (optional)
+ * @param {string} [element.comparison] - use for query in queryElements.sortKeyCondition. (optional)
+ * @param {string} [element.conditionalFieldValues] - user after query for filter data before save to logicalData table. (optional)
+ * @param {boolean} overWriteCache
+ *
+ * @returns {string} description of return value
+ */
+
+export default async function processLogical(
+  _izContext,
+  objType,
+  element,
+  overWriteCache,
+  callingFlow
+) {
+  try {
+    _izContext.logger.debug('----- ProcessLogical event params -----', {
+      objType: objType,
+      element: element,
+      overWriteCache: overWriteCache,
+      callingFlow: callingFlow
+    });
+
+    let removeAttributes = ['paginateProcessLogicalUniqueRequestId'];
+
+    //(<removeAttributes>)
+    //(</removeAttributes>)
+
+    // Check/Create logicalResultsMain
+    let [logicalResultsMainStatus, logicalResultId, logicalResultMain] =
+      await logicalResultsSharedLib.checkLogicalMainStatus(
+        _izContext,
+        element, // for create logicalResultId
+        objType,
+        callingFlow,
+        removeAttributes,
+        overWriteCache
+      );
+    _izContext.logger.debug('After check logicalMainStatus: ', {
+      logicalResultsMainStatus: logicalResultsMainStatus,
+      logicalResultId: logicalResultId,
+      logicalResultMain: logicalResultMain
+    });
+
+    if (logicalResultsMainStatus !== 'process') {
+      _izContext.logger.debug(
+        `logicalResultsMainStatus status isn't process :${logicalResultsMainStatus}`
+      );
+      return {
+        returnResponse: 'logicalResultsMainStatus status is not process'
+      };
+    }
+
+    let errorsFound = [];
+
+    let standardErrorParams = [
+      _izContext,
+      logicalResultId,
+      logicalResultMain.logicalElement,
+      logicalResultMain.objType,
+      overWriteCache,
+      callingFlow,
+      'error'
+    ];
+
+    if (
+      element.comparison &&
+      !searchResultSharedLib.consts.POSSIBLE_COMPARISON_SORTID.includes(
+        element.comparison
+      )
+    ) {
+      errorsFound.push('comparison is not possible comparison');
+    }
+
+    // validate partitionKeyValues
+    if (!element.hasOwnProperty('partitionKeyValues')) {
+      _izContext.logger.debug('element not have partitionKeyValues');
+      errorsFound.push('element not have partitionKeyValues');
+    } else if (Object.keys(element.partitionKeyValues).length === 0) {
+      _izContext.logger.debug('partitionKeyValues is empty');
+      errorsFound.push('partitionKeyValues is empty');
+    }
+
+    const objectSchemas = await getObjectSchema.getObjSchemaS3WithHierarchy(
+      _izContext,
+      objType
+    );
+    _izContext.logger.debug('objectSchemas: ', objectSchemas);
+
+    let partitionKeyFieldName = null;
+    let tableName = null;
+    let sortKeyFieldName = null;
+
+    for (const schemasIdentifier of objectSchemas.identifiers) {
+      if (schemasIdentifier.type === 'partitionKey') {
+        if (partitionKeyFieldName === null) {
+          if (schemasIdentifier.hasOwnProperty('fieldName')) {
+            partitionKeyFieldName = schemasIdentifier.fieldName;
+          } else {
+            partitionKeyFieldName = schemasIdentifier.name;
+          }
+        } else {
+          throw new NoRetryError(
+            'Invalid object schemas have more than one partitionKey'
+          );
+        }
+      }
+
+      if (schemasIdentifier.type === 'sortKey') {
+        if (sortKeyFieldName === null) {
+          if (schemasIdentifier.hasOwnProperty('fieldName')) {
+            sortKeyFieldName = schemasIdentifier.fieldName;
+          } else {
+            sortKeyFieldName = schemasIdentifier.name;
+          }
+        } else {
+          throw new NoRetryError(
+            'Invalid object schemas have more than one sortKey'
+          );
+        }
+        _izContext.logger.debug('have sortKeyFieldName: ', sortKeyFieldName);
+      }
+    }
+
+    const storageResources = objectSchemas.storageResources;
+
+    storageResourcesLoop: for (const storageResourceTag of Object.keys(
+      storageResources
+    )) {
+      _izContext.logger.debug('check storageResourceTag: ', storageResourceTag);
+
+      if (
+        storageResources[storageResourceTag].storageType ===
+        STORAGE_TYPES.dynamoDB
+      ) {
+        if (
+          storageResources[storageResourceTag].hasOwnProperty(
+            'groupByPartitionKeyField'
+          )
+        ) {
+          if (element.hasOwnProperty('sortKeyValues')) {
+            continue;
+          } else {
+            errorsFound.push(
+              'schema error: dynamo storageResource set to groupByPartitionKeyField but no sortKey'
+            );
+            break;
+          }
+        }
+
+        // validate conditionalFieldValues
+        if (
+          element.hasOwnProperty('conditionalFieldValues') &&
+          element.conditionalFieldValues.length > 0
+        ) {
+          conditionalFieldValuesLoop: for (const conditionalFieldValue of element.conditionalFieldValues) {
+            let conditionalFieldName = conditionalFieldValue.fieldName;
+            let storageResourceTagsFieldName =
+              objectSchemas.fieldNames[conditionalFieldName]
+                .storageResourceTags;
+
+            if (storageResourceTagsFieldName.includes(storageResourceTag)) {
+              continue conditionalFieldValuesLoop;
+            } else {
+              continue storageResourcesLoop;
+            }
+          }
+        }
+
+        tableName = storageResources[storageResourceTag].tableName;
+        _izContext.logger.debug('found tableName: ', tableName);
+        break;
+      }
+    }
+
+    if (!tableName) {
+      errorsFound.push('no valid dynamo storageResource found');
+    }
+
+    if (
+      element.hasOwnProperty('sortKeyValues') &&
+      Object.keys(element.sortKeyValues).length > 0 &&
+      !sortKeyFieldName
+    ) {
+      _izContext.logger.debug(
+        'element have sortKeyValues but cannot find sortKey in object schemas'
+      );
+      errorsFound.push(
+        'element have sortKeyValues but cannot find sortKey in object schemas'
+      );
+    }
+
+    if (errorsFound.length > 0) {
+      _izContext.logger.debug('Have errorsFound: ', errorsFound);
+      standardErrorParams.push(errorsFound);
+      await logicalResultsSharedLib.completeLogicalResultsMain(
+        ...standardErrorParams
+      );
+      return {
+        returnResponse: 'Have errorsFound'
+      };
+    }
+
+    // concatenate partitionKey
+    let partitionKeyReqIdentifiers = {};
+    for (const [fieldName, fieldNameValue] of Object.entries(
+      element.partitionKeyValues
+    )) {
+      partitionKeyReqIdentifiers[fieldName] = fieldNameValue.value;
+    }
+
+    // concatenate sortKey
+    if (element.hasOwnProperty('sortKeyValues')) {
+      for (const [fieldName, fieldNameValue] of Object.entries(
+        element.sortKeyValues
+      )) {
+        partitionKeyReqIdentifiers[fieldName] = fieldNameValue.value;
+      }
+    }
+    _izContext.logger.debug(
+      'partitionKeyReqIdentifiers: ',
+      partitionKeyReqIdentifiers
+    );
+
+    let dynamoDbIdentifiers =
+      await identifierObj.dynamoDbIdentifiersByStorageResource(
+        _izContext,
+        objectSchemas,
+        storageResources,
+        partitionKeyReqIdentifiers
+      );
+    _izContext.logger.debug('dynamoDbIdentifiers: ', dynamoDbIdentifiers);
+
+    if (element.hasOwnProperty('sortKeyValues')) {
+      let comparison = 'equals';
+      if (element.comparison && element.comparison !== 'equals') {
+        comparison = element.comparison;
+        let sentMessageToPaginateProcessLogical = {
+          Message: JSON.stringify({
+            logicalResultId: logicalResultId,
+            tableName: tableName,
+            partitionKeyFieldName: partitionKeyFieldName,
+            sortKeyFieldName: sortKeyFieldName,
+            dynamoDbIdentifiers: dynamoDbIdentifiers,
+            comparison: comparison,
+            overWriteCache: overWriteCache,
+            callingFlow: callingFlow
+          }),
+          TopicArn: await snsSharedLib.snsTopicArnByFlowSchema(
+            _izContext,
+            'PaginateProcessLogical_In'
+          )
+        };
+        _izContext.logger.debug(
+          'Request params before send to topic PaginateProcessLogical_In: ',
+          sentMessageToPaginateProcessLogical
+        );
+
+        let resSNS = await sns.publishAsync(
+          _izContext,
+          sentMessageToPaginateProcessLogical
+        );
+        _izContext.logger.debug(
+          'resSNS send to topic ProcessSortResult finish!',
+          resSNS
+        );
+
+        return {
+          returnResponse: 'Send message to PaginateProcessLogical_In'
+        };
+      } else {
+        let queryDatas = await dynamodbSharedLib.query(
+          _izContext,
+          dynamodbSharedLib.tableName(_izContext, tableName),
+          {
+            [partitionKeyFieldName]: dynamoDbIdentifiers[partitionKeyFieldName]
+          },
+          {
+            sortKeyCondition: {
+              comparison: comparison,
+              name: sortKeyFieldName,
+              value: dynamoDbIdentifiers[sortKeyFieldName]
+            }
+          }
+        );
+        _izContext.logger.debug('queryDatas result: ', queryDatas);
+
+        if (queryDatas.Items.length == 0) {
+          _izContext.logger.debug(`can't find data in ${tableName}`);
+          errorsFound.push(`can't find data in ${tableName}`);
+          standardErrorParams.push(errorsFound);
+          await logicalResultsSharedLib.completeLogicalResultsMain(
+            ...standardErrorParams
+          );
+          return {
+            returnResponse: 'Cannot find data in table'
+          };
+        }
+
+        for (const objInstanceBase of queryDatas.Items) {
+          await logicalResultsSharedLib.saveLogicalData(
+            _izContext,
+            logicalResultId,
+            logicalResultMain.objType,
+            objInstanceBase
+          );
+        }
+      }
+    } else {
+      // element don't have sortKey
+
+      if (sortKeyFieldName) {
+        _izContext.logger.debug(
+          'identifiers have sortKey: query dynamo in PaginateProcessLogical'
+        );
+
+        let sentMessageToPaginateProcessLogical = {
+          Message: JSON.stringify({
+            logicalResultId: logicalResultId,
+            tableName: tableName,
+            partitionKeyFieldName: partitionKeyFieldName,
+            sortKeyFieldName: sortKeyFieldName,
+            dynamoDbIdentifiers: dynamoDbIdentifiers,
+            overWriteCache: overWriteCache,
+            callingFlow: callingFlow
+          }),
+          TopicArn: await snsSharedLib.snsTopicArnByFlowSchema(
+            _izContext,
+            'PaginateProcessLogical_In'
+          )
+        };
+        _izContext.logger.debug(
+          'Request params before send to topic PaginateProcessLogical_In: ',
+          sentMessageToPaginateProcessLogical
+        );
+
+        let resSNS = await sns.publishAsync(
+          _izContext,
+          sentMessageToPaginateProcessLogical
+        );
+        _izContext.logger.debug(
+          'resSNS send to topic ProcessSortResult finish!',
+          resSNS
+        );
+
+        return {
+          returnResponse: 'Send message to PaginateProcessLogical_In'
+        };
+      } else {
+        _izContext.logger.debug('identifiers not have sortKey: save dataId');
+
+        let getDataByPartitionKey = await dynamodbSharedLib.getItem(
+          _izContext,
+          dynamodbSharedLib.tableName(_izContext, tableName),
+          {
+            [partitionKeyFieldName]: dynamoDbIdentifiers[partitionKeyFieldName]
+          }
+        );
+
+        if (getDataByPartitionKey) {
+          await logicalResultsSharedLib.saveLogicalData(
+            _izContext,
+            logicalResultId,
+            objType,
+            getDataByPartitionKey
+          );
+        } else {
+          _izContext.logger.debug(`can't find data in ${tableName}`);
+          errorsFound.push(`can't find data in ${tableName}`);
+          standardErrorParams.push(errorsFound);
+          await logicalResultsSharedLib.completeLogicalResultsMain(
+            ...standardErrorParams
+          );
+          return {
+            returnResponse: 'Cannot find data in table'
+          };
+        }
+      }
+    }
+
+    // complete processLogical and send message Out
+    await logicalResultsSharedLib.completeLogicalResultsMain(
+      _izContext,
+      logicalResultId,
+      element,
+      objType,
+      overWriteCache,
+      callingFlow,
+      'complete',
+      []
+    );
+
+    //(<additionalProcessLogical>)
+    //(</additionalProcessLogical>)
+
+    return {
+      returnResponse: 'Function ProcessLogical is Finished'
+    };
+  } catch (err) {
+    _izContext.logger.error('error ProcessLogicalMain: ', err);
+    throw err;
+  }
+}

package/src/emit/system/emitSystemFindDataArtifacts.js

@@ -0,0 +1,266 @@
+import ejsLib from 'ejs';
+import { readFile } from 'node:fs/promises';
+
+const SHARED_TEMPLATE_URL = new URL('../shared/templates/', import.meta.url);
+const FIND_DATA_SOURCE = 'app/src/generatedCode/FindData/source';
+const FIND_DATA_HANDLER_ROOT = 'src/generatedCode/FindData/source';
+const PROCESS_LOGICAL_SOURCE = 'app/src/generatedCode/ProcessLogical/source';
+const PROCESS_LOGICAL_HANDLER_ROOT = 'src/generatedCode/ProcessLogical/source';
+const YAML_PATH = 'app/sls_yaml/generatedCode/source/flow-system.yml';
+
+const STORAGE_TYPES = { dynamoDB: 'dynamoDB', graph: 'graph' };
+
+export async function emitSystemFindDataArtifacts(objects) {
+  return _emitSystemArtifacts(objects);
+}
+
+export function findDataManagedPaths() {
+  return [
+    `${FIND_DATA_SOURCE}/FindData_Main.js`,
+    `${FIND_DATA_SOURCE}/FindData_HdrSqs.js`,
+    `${PROCESS_LOGICAL_SOURCE}/ProcessLogical_Main.js`,
+    `${PROCESS_LOGICAL_SOURCE}/ProcessLogical_HdrSqs.js`,
+    `${PROCESS_LOGICAL_SOURCE}/PaginateProcessLogical_Main.js`,
+    `${PROCESS_LOGICAL_SOURCE}/PaginateProcessLogical_HdrDsq.js`,
+    `${PROCESS_LOGICAL_SOURCE}/PaginateProcessLogical_HdrSqs.js`,
+    YAML_PATH
+  ];
+}
+
+function _hasStorageObjects(objects) {
+  if (!Array.isArray(objects) || objects.length === 0) {
+    return false;
+  }
+  return objects.some(
+    (object) =>
+      object.storageResources &&
+      Object.keys(object.storageResources).length > 0
+  );
+}
+
+async function _emitSystemArtifacts(objects) {
+  if (!_hasStorageObjects(objects)) {
+    return [];
+  }
+
+  const hasFindDataEntries = buildFindDataEntries(objects).length > 0;
+
+  const artifacts = [];
+
+  if (hasFindDataEntries) {
+    const findDataMain = await render('FindData_Main.ejs', {
+      datas: buildFindDataEntries(objects)
+    });
+    artifacts.push(
+      { path: `${FIND_DATA_SOURCE}/FindData_Main.js`, content: findDataMain },
+      {
+        path: `${FIND_DATA_SOURCE}/FindData_HdrSqs.js`,
+        content: await render('FindData_HdrSqs.ejs', {})
+      }
+    );
+  }
+
+  artifacts.push(
+    {
+      path: `${PROCESS_LOGICAL_SOURCE}/ProcessLogical_Main.js`,
+      content: await render('ProcessLogical_Main.ejs', {})
+    },
+    {
+      path: `${PROCESS_LOGICAL_SOURCE}/ProcessLogical_HdrSqs.js`,
+      content: await render('ProcessLogical_HdrSqs.ejs', {})
+    },
+    {
+      path: `${PROCESS_LOGICAL_SOURCE}/PaginateProcessLogical_Main.js`,
+      content: await render('PaginateProcessLogical_Main.ejs', {})
+    },
+    {
+      path: `${PROCESS_LOGICAL_SOURCE}/PaginateProcessLogical_HdrDsq.js`,
+      content: await render('PaginateProcessLogical_HdrDsq.ejs', {})
+    },
+    {
+      path: `${PROCESS_LOGICAL_SOURCE}/PaginateProcessLogical_HdrSqs.js`,
+      content: await render('PaginateProcessLogical_HdrSqs.ejs', {})
+    },
+    {
+      path: YAML_PATH,
+      content: renderSystemYaml()
+    }
+  );
+
+  return artifacts;
+}
+
+function renderSystemYaml() {
+  const findDataYaml = renderFindDataYaml();
+  const processLogicalYaml = renderProcessLogicalYaml();
+  const processLogicalPaginateDsqYaml = renderProcessLogicalPaginateDsqYaml();
+  const processLogicalPaginateSqsYaml = renderProcessLogicalPaginateSqsYaml();
+  return [
+    findDataYaml,
+    processLogicalYaml,
+    processLogicalPaginateDsqYaml,
+    processLogicalPaginateSqsYaml
+  ].join('\n\n');
+}
+
+function renderFindDataYaml() {
+  return _renderSqsYaml({
+    functionName: 'FindData',
+    handlerRoot: FIND_DATA_HANDLER_ROOT,
+    roleName: 'ProcFindDataRole'
+  });
+}
+
+function renderProcessLogicalYaml() {
+  return _renderSqsYaml({
+    functionName: 'ProcessLogical',
+    handlerRoot: PROCESS_LOGICAL_HANDLER_ROOT,
+    roleName: 'ProcFindDataRole'
+  });
+}
+
+function renderProcessLogicalPaginateDsqYaml() {
+  return _renderSqsYaml({
+    functionName: 'PaginateProcessLogical',
+    handlerType: 'HdrDsq',
+    handlerRoot: PROCESS_LOGICAL_HANDLER_ROOT,
+    roleName: 'ProcFindDataRole'
+  });
+}
+
+function renderProcessLogicalPaginateSqsYaml() {
+  return _renderSqsYaml({
+    functionName: 'PaginateProcessLogical',
+    handlerRoot: PROCESS_LOGICAL_HANDLER_ROOT,
+    roleName: 'ProcFindDataRole'
+  });
+}
+
+function _renderSqsYaml({
+  functionName,
+  handlerType = 'HdrSqs',
+  handlerRoot,
+  roleName
+}) {
+  const upperHandlerType = handlerType;
+  const handlerPath = `${handlerRoot}/${functionName}_${upperHandlerType}.main`;
+  const name = `${functionName}${upperHandlerType}`;
+  return `${name}:
+  handler: ${handlerPath}
+  name: \${self:custom.iz_resourcePrefix}${name}
+  role: ${roleName}
+  #<#${name}FunctionSetting#>
+  #<#/${name}FunctionSetting#>
+  events:
+    - sqs:
+        arn: arn:aws:sqs:\${self:custom.iz_region}:\${self:custom.iz_accountId}:\${self:custom.iz_resourcePrefix}${name}
+        batchSize: 10`;
+}
+
+function buildFindDataEntries(objects) {
+  return objects
+    .filter(
+      (object) =>
+        object.storageResources &&
+        Object.keys(object.storageResources).length > 0
+    )
+    .map((object) => {
+      const objectType = object.objectType;
+      const storageResources = object.storageResources;
+      const fieldNames = object.fieldNames || {};
+      const identifiers = object.identifiers || [];
+      const identifierNames = new Set(
+        identifiers.map((id) => id.fieldName).filter(Boolean)
+      );
+
+      const fieldEntries = [];
+
+      for (const [field, schemas] of Object.entries(fieldNames)) {
+        if (schemas.type !== 'string' && schemas.type !== 'number') {
+          continue;
+        }
+
+        const storageResourceTags = schemas.storageResourceTags;
+        if (
+          !Array.isArray(storageResourceTags) ||
+          storageResourceTags.length === 0
+        ) {
+          continue;
+        }
+
+        const collectStorageDetail = {};
+        const getInIdentifiers = identifierNames.has(field);
+
+        for (const storageTag of storageResourceTags) {
+          const storageDetail = storageResources[storageTag];
+          if (!storageDetail) {
+            continue;
+          }
+
+          if (storageDetail.storageType === STORAGE_TYPES.graph) {
+            if (!collectStorageDetail[STORAGE_TYPES.graph]) {
+              collectStorageDetail[STORAGE_TYPES.graph] = {
+                graphServerTag: storageDetail.graphServerTag,
+                getInIdentifiers
+              };
+            }
+          } else if (storageDetail.storageType === STORAGE_TYPES.dynamoDB) {
+            if (!collectStorageDetail[STORAGE_TYPES.dynamoDB]) {
+              collectStorageDetail[STORAGE_TYPES.dynamoDB] = {
+                tableName: storageDetail.tableName
+              };
+            }
+          }
+        }
+
+        if (
+          collectStorageDetail[STORAGE_TYPES.graph] &&
+          collectStorageDetail[STORAGE_TYPES.dynamoDB]
+        ) {
+          delete collectStorageDetail[STORAGE_TYPES.graph];
+        }
+
+        if (Object.keys(collectStorageDetail).length > 0) {
+          fieldEntries.push({ [field]: collectStorageDetail });
+        }
+      }
+
+      if (Array.isArray(object.addOnDataStructure)) {
+        for (const versionedData of object.addOnDataStructure) {
+          if (versionedData.type === 'versionedData') {
+            const versionedStorageTag = versionedData.storageResourceTag;
+            const versionedFieldNames = versionedData.fieldNames || {};
+            const storageDetail = storageResources[versionedStorageTag];
+
+            if (
+              storageDetail &&
+              storageDetail.storageType === STORAGE_TYPES.graph
+            ) {
+              const versionedStorageDetail = {
+                [STORAGE_TYPES.graph]: {
+                  graphServerTag: storageDetail.graphServerTag,
+                  versionedDataLabel: versionedData.versionedDataLabel
+                }
+              };
+
+              for (const [key, value] of Object.entries(versionedFieldNames)) {
+                if (value.type === 'string' || value.type === 'number') {
+                  fieldEntries.push({ [key]: versionedStorageDetail });
+                }
+              }
+            }
+          }
+        }
+      }
+
+      return { objectType, fieldNames: fieldEntries };
+    })
+    .filter((entry) => entry.fieldNames.length > 0);
+}
+
+async function render(templateName, data) {
+  return ejsLib.render(
+    await readFile(new URL(templateName, SHARED_TEMPLATE_URL), 'utf8'),
+    data
+  );
+}