@izara_project/izara-core-generate-service-code 1.0.1 → 1.0.2

package/src/TemplateData/flowSchema/webSocketComplete/sqs/templateSub.ejs

@@ -0,0 +1,7 @@
+##===== SNS Subscription
+  SubscriptionToOut<%- subscribeTo %>:
+    Type: AWS::SNS::Subscription
+    Properties:
+      TopicArn: !Ref Out<%- subscribeTo %>
+      Endpoint: "arn:aws:sqs:${self:custom.iz_region}:${self:custom.iz_accountId}:${self:custom.iz_resourcePrefix}<%- queueName %>"
+      Protocol: "sqs"

package/src/TemplateData/generateRole/createSharedResource.js

@@ -0,0 +1,469 @@
+/*
+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/>.
+*/
+
+const {
+  SOURCE_GENERATE_IAM_ROLE,
+  SOURCE_PATH,
+  SAVE_FILE_NAME
+} = require('../../../MainLibs/src/Consts');
+const { firstLetterUpperCase: upperCase } =
+  require('../../../MainLibs/index').utils;
+const path = require('path');
+
+/**
+ * Process additional resource permissions for an object type
+ * @param {Array} resourcePermissions - Array of resource permissions to process
+ * @param {Object} targetResources - Resources object to update
+ */
+const processResourcePermissions = (resourcePermissions, targetResources) => {
+  if (!Array.isArray(resourcePermissions)) return;
+  resourcePermissions.forEach(resourcePermission => {
+    if (!resourcePermission.action) return;
+    const [key, value] = Object.entries(resourcePermission.action)[0];
+    if (!targetResources[key]) {
+      targetResources[key] = [];
+    }
+    const actionsList = Array.isArray(value) ? value : [value];
+    const resourcesList = Array.isArray(resourcePermission.resource)
+      ? resourcePermission.resource
+      : [resourcePermission.resource];
+    // Check if entry with same actions exists
+    const existingEntry = targetResources[key].find(
+      entry => JSON.stringify(entry.actions) === JSON.stringify(actionsList)
+    );
+    if (existingEntry) {
+      // Merge resources without duplicates
+      existingEntry.resource = [
+        ...new Set([...existingEntry.resource, ...resourcesList])
+      ];
+    } else {
+      // Add new entry
+      targetResources[key].push({
+        actions: actionsList,
+        resource: resourcesList
+      });
+    }
+  });
+};
+
+/**
+ * Check if an item should be skipped based on templateData content
+ * @param {Object} templateData - Template data to check
+ * @returns {Boolean} True if item should be skipped
+ */
+const shouldSkipItem = templateData => {
+  return (
+    !templateData ||
+    Object.keys(templateData).length === 0 ||
+    !templateData.additionalResourcePermission
+  );
+};
+
+/**
+ * Initialize object type structure if it doesn't exist
+ * @param {Object} groupedByObjectType - The grouped object
+ * @param {String} objectType - Object type to initialize
+ * @param {Array} objectTypeList - List to track object types
+ */
+const initializeObjectType = (
+  groupedByObjectType,
+  objectType,
+  objectTypeList
+) => {
+  if (!groupedByObjectType[objectType]) {
+    groupedByObjectType[objectType] = {
+      functionNames: [],
+      actions: [],
+      resources: {},
+      actionHandler: []
+    };
+    objectTypeList.push(objectType);
+  }
+};
+const createSharedResource = (_izContext, createSourceParams, srcPath) => {
+  // Initialize data structure
+  const groupedByObjectType = {
+    [SOURCE_GENERATE_IAM_ROLE.ProcessFindDataRole]: {
+      handlerType: [],
+      resources: {}
+    },
+    [SOURCE_GENERATE_IAM_ROLE.ObjectCompleteRole]: {
+      functionNames: [],
+      handlerType: [],
+      resources: {}
+    },
+    [SOURCE_GENERATE_IAM_ROLE.RelationshipRole]: {
+      handlerType: [],
+      resources: {}
+    },
+    [SOURCE_GENERATE_IAM_ROLE.RelationshipCompleteRole]: {
+      handlerType: [],
+      resources: []
+    },
+    [SOURCE_GENERATE_IAM_ROLE.FlowSchemaUploadS3Role]: {
+      handlerType: [],
+      resources: {}
+    },
+    [SOURCE_GENERATE_IAM_ROLE.PerActionEndpoint]: {
+      handlerType: [],
+      resources: {}
+    },
+    [SOURCE_GENERATE_IAM_ROLE.FlowSchemaOwnTopic]: {
+      handlerType: [],
+      resources: {}
+    },
+    [SOURCE_GENERATE_IAM_ROLE.ExternalTopicRole]: {
+      handlerType: [],
+      resources: {}
+    },
+    WebSocketMain: {
+      handlerType: [],
+      resources: {}
+    },
+    [SOURCE_GENERATE_IAM_ROLE.EventBridge]: {
+      handlerType: [],
+      resources: {}
+    },
+    [SOURCE_GENERATE_IAM_ROLE.CreateRecordComplete]: {
+      handlerType: [],
+      resources: {}
+    },
+    [SOURCE_GENERATE_IAM_ROLE.RegisterRole]: {
+      handlerType: [],
+      resources: {}
+    },
+    Other: []
+  };
+  const objectTypeList = [];
+  // Ensure data is defined - assuming it comes from createSourceParams
+  const data = createSourceParams || [];
+  // Process each item in data
+  data.map(item => {
+    const templateData = item.templateData;
+    if (shouldSkipItem(templateData)) return;
+
+    // ? Handle items with objectType and roleName
+    if (templateData.objectType) {
+      const objectType = templateData.roleName
+        ? templateData.roleName
+        : templateData.objectType;
+      // Handle items with objectType
+      initializeObjectType(groupedByObjectType, objectType, objectTypeList);
+      // Add function name if it doesn't exist
+      if (
+        templateData.functionName &&
+        !groupedByObjectType[objectType].functionNames?.includes(
+          templateData.functionName
+        )
+      ) {
+        groupedByObjectType[objectType].functionNames.push(
+          templateData.functionName
+        );
+      }
+      // Add action if it doesn't exist
+      if (
+        templateData.action !== null &&
+        !groupedByObjectType[objectType].actions?.includes(templateData.action)
+      ) {
+        groupedByObjectType[objectType].actions.push(templateData.action);
+      }
+      // Process additionalResourcePermission
+      processResourcePermissions(
+        templateData.additionalResourcePermission,
+        groupedByObjectType[objectType].resources
+      );
+    } else if (
+      templateData.functionName &&
+      (templateData.functionName.includes([
+        SOURCE_GENERATE_IAM_ROLE.ObjectCompleteRole
+      ]) ||
+        templateData.functionName.includes([
+          SOURCE_GENERATE_IAM_ROLE.NodeCompleteRole
+        ]))
+    ) {
+      // Handle ObjectComplete items
+      groupedByObjectType[
+        SOURCE_GENERATE_IAM_ROLE.ObjectCompleteRole
+      ].functionNames.push(templateData.functionName);
+      groupedByObjectType[
+        SOURCE_GENERATE_IAM_ROLE.ObjectCompleteRole
+      ].handlerType.push(templateData.handlerType);
+      processResourcePermissions(
+        templateData.additionalResourcePermission,
+        groupedByObjectType[SOURCE_GENERATE_IAM_ROLE.ObjectCompleteRole]
+          .resources
+      );
+    } else if (
+      templateData.functionName &&
+      templateData.functionName.includes([
+        SOURCE_GENERATE_IAM_ROLE.RelationshipRole
+      ])
+    ) {
+      if (
+        templateData.functionName.includes([
+          SOURCE_GENERATE_IAM_ROLE.RelationshipCompleteRole
+        ])
+      ) {
+        // Handle RelationshipComplete items
+        if (
+          templateData.handlerType &&
+          !groupedByObjectType[
+            SOURCE_GENERATE_IAM_ROLE.RelationshipCompleteRole
+          ].handlerType.includes(templateData.handlerType)
+        ) {
+          groupedByObjectType[
+            SOURCE_GENERATE_IAM_ROLE.RelationshipCompleteRole
+          ].handlerType.push(templateData.handlerType);
+        }
+        processResourcePermissions(
+          templateData.additionalResourcePermission,
+          groupedByObjectType[SOURCE_GENERATE_IAM_ROLE.RelationshipCompleteRole]
+            .resources
+        );
+      } else {
+        // Handle regular Relationship items
+        if (
+          templateData.handlerType &&
+          !groupedByObjectType[
+            SOURCE_GENERATE_IAM_ROLE.RelationshipRole
+          ].handlerType.includes(templateData.handlerType)
+        ) {
+          groupedByObjectType[
+            SOURCE_GENERATE_IAM_ROLE.RelationshipRole
+          ].handlerType.push(templateData.handlerType);
+        }
+        processResourcePermissions(
+          templateData.additionalResourcePermission,
+          groupedByObjectType[SOURCE_GENERATE_IAM_ROLE.RelationshipRole]
+            .resources
+        );
+      }
+    } else if (
+      templateData.functionName &&
+      (templateData.functionName.includes('PaginateProcessLogical') ||
+        templateData.functionName.includes('FindData') ||
+        templateData.functionName.includes('ProcessLogical'))
+    ) {
+      // Handle ProcessFindData items
+      groupedByObjectType[
+        SOURCE_GENERATE_IAM_ROLE.ProcessFindDataRole
+      ].handlerType.push(templateData.handlerType);
+      processResourcePermissions(
+        templateData.additionalResourcePermission,
+        groupedByObjectType[SOURCE_GENERATE_IAM_ROLE.ProcessFindDataRole]
+          .resources
+      );
+    } else if (
+      templateData?.roleName?.includes(
+        SOURCE_GENERATE_IAM_ROLE.FlowSchemaUploadS3Role
+      )
+    ) {
+      groupedByObjectType[
+        SOURCE_GENERATE_IAM_ROLE.FlowSchemaUploadS3Role
+      ].handlerType.push(templateData);
+      processResourcePermissions(
+        templateData.additionalResourcePermission,
+        groupedByObjectType[SOURCE_GENERATE_IAM_ROLE.FlowSchemaUploadS3Role]
+          .resources
+      );
+    } else if (
+      templateData?.roleName?.includes(
+        SOURCE_GENERATE_IAM_ROLE.PerActionEndpoint
+      )
+    ) {
+      groupedByObjectType[
+        SOURCE_GENERATE_IAM_ROLE.PerActionEndpoint
+      ].handlerType.push(templateData);
+      processResourcePermissions(
+        templateData.additionalResourcePermission,
+        groupedByObjectType[SOURCE_GENERATE_IAM_ROLE.PerActionEndpoint]
+          .resources
+      );
+    } else if (
+      templateData?.roleName?.includes(
+        SOURCE_GENERATE_IAM_ROLE.FlowSchemaOwnTopic
+      )
+    ) {
+      groupedByObjectType[
+        SOURCE_GENERATE_IAM_ROLE.FlowSchemaOwnTopic
+      ].handlerType.push(templateData);
+      processResourcePermissions(
+        templateData.additionalResourcePermission,
+        groupedByObjectType[SOURCE_GENERATE_IAM_ROLE.FlowSchemaOwnTopic]
+          .resources
+      );
+    } else if (
+      templateData?.roleName?.includes(
+        SOURCE_GENERATE_IAM_ROLE.ExternalTopicRole
+      )
+    ) {
+      groupedByObjectType[
+        SOURCE_GENERATE_IAM_ROLE.ExternalTopicRole
+      ].handlerType.push(templateData);
+      processResourcePermissions(
+        templateData.additionalResourcePermission,
+        groupedByObjectType[SOURCE_GENERATE_IAM_ROLE.ExternalTopicRole]
+          .resources
+      );
+    } else if (templateData?.roleName?.includes('WebSocketMain')) {
+      groupedByObjectType['WebSocketMain'].handlerType.push(templateData);
+      processResourcePermissions(
+        templateData.additionalResourcePermission,
+        groupedByObjectType['WebSocketMain'].resources
+      );
+    } else if (
+      templateData?.roleName?.includes(SOURCE_GENERATE_IAM_ROLE.EventBridge)
+    ) {
+      groupedByObjectType[
+        SOURCE_GENERATE_IAM_ROLE.EventBridge
+      ].handlerType.push(templateData);
+      processResourcePermissions(
+        templateData.additionalResourcePermission,
+        groupedByObjectType[SOURCE_GENERATE_IAM_ROLE.EventBridge].resources
+      );
+    } else if (
+      templateData?.roleName?.includes(
+        SOURCE_GENERATE_IAM_ROLE.CreateRecordComplete
+      )
+    ) {
+      groupedByObjectType[
+        SOURCE_GENERATE_IAM_ROLE.CreateRecordComplete
+      ].handlerType.push(templateData);
+      processResourcePermissions(
+        templateData.additionalResourcePermission,
+        groupedByObjectType[SOURCE_GENERATE_IAM_ROLE.CreateRecordComplete]
+          .resources
+      );
+    } else if (
+      templateData?.roleName?.includes(SOURCE_GENERATE_IAM_ROLE.RegisterRole)
+    ) {
+      groupedByObjectType[
+        SOURCE_GENERATE_IAM_ROLE.RegisterRole
+      ].handlerType.push(templateData);
+      processResourcePermissions(
+        templateData.additionalResourcePermission,
+        groupedByObjectType[SOURCE_GENERATE_IAM_ROLE.RegisterRole].resources
+      );
+    } else {
+      // Handle other items
+      groupedByObjectType.Other.push(item);
+    }
+    return item;
+  });
+
+  // Process "Other" items that might belong to existing object types
+  groupedByObjectType.Other = groupedByObjectType.Other.filter(item => {
+    const templateData = item.templateData;
+    if (!templateData.functionName) return true;
+    // Find matching objectType
+    const matchedObjectType = objectTypeList.find(
+      objectType =>
+        templateData.functionName
+          .toLowerCase()
+          .includes(objectType.toLowerCase()) ||
+        templateData.functionName.includes(
+          objectType.charAt(0).toUpperCase() + objectType.slice(1)
+        )
+    );
+    if (matchedObjectType) {
+      // Move the item to the matched object type
+      groupedByObjectType[matchedObjectType].actionHandler.push(
+        templateData.handlerType
+      );
+      groupedByObjectType[matchedObjectType].resources = {
+        ...groupedByObjectType[matchedObjectType].resources,
+        ...templateData.additionalResourcePermission
+      };
+      return false; // Remove from Other
+    }
+    return true; // Keep in Other
+  });
+  // Prepare results
+
+  // Process and prepare data for role definitions and extract any resources
+  // that might be related to object types but weren't categorized properly
+  const roles = [];
+  Object.entries(groupedByObjectType).forEach(([objectType, data]) => {
+    if (objectType === 'Other' || !data.resources) return;
+    // create policy statements from resources
+    const rolePolicyStatement = [];
+    Object.entries(data.resources).forEach(([effect, permissionList]) => {
+      if (!Array.isArray(permissionList)) {
+        // permissionList might be in a different format
+        if (
+          typeof permissionList === 'object' &&
+          !Array.isArray(permissionList)
+        ) {
+          // Handle non-standard format
+          const actions = [];
+          if (permissionList.action) {
+            const actionObj = permissionList.action;
+            Object.entries(actionObj).forEach(([service, actionList]) => {
+              const actionArray = Array.isArray(actionList)
+                ? actionList
+                : [actionList];
+              actionArray.forEach(action =>
+                actions.push(`${service}:${action}`)
+              );
+            });
+          }
+          rolePolicyStatement.push({
+            Effect: permissionList.effect || 'Allow',
+            Action: actions,
+            Resource: permissionList.resource
+          });
+          return;
+        }
+        rolePolicyStatement.push({
+          Effect: permissionList.effect,
+          Action: actions,
+          Resource: permission.resource
+        });
+        return;
+      }
+      permissionList.forEach(permission => {
+        const actions = permission.actions.map(action => `${effect}:${action}`);
+        rolePolicyStatement.push({
+          Effect: 'Allow',
+          Action: actions,
+          Resource: permission.resource
+        });
+      });
+    });
+    if (rolePolicyStatement.length > 0) {
+      roles.push({
+        roleName: upperCase(objectType),
+        rolePolicyStatement
+      });
+    }
+  });
+  const sharedResourceTemplatePath = path.join(
+    __dirname,
+    './sharedResourceTemplate.ejs'
+  );
+
+  return {
+    templatePath: sharedResourceTemplatePath,
+    templateData: { roles },
+    setting: {
+      initialData: 'Resources:\n',
+      savePath: path.join(srcPath, SOURCE_PATH.appYaml),
+      saveFileName: SAVE_FILE_NAME.sharedResourceYaml,
+      fileExtension: '.yml',
+      isAppend: true
+    }
+  };
+};
+
+export default createSharedResource;

package/src/TemplateData/generateRole/data.js

@@ -0,0 +1,92 @@
+/*
+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 path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+import consts from '../../../MainLibs/src/Consts.js';
+const { SOURCE_PATH, SAVE_FILE_NAME } = consts;
+
+const templatePath = path.join(__dirname, 'template.ejs');
+
+function generateRole(_izContext, createSourceParams, srcPath) {
+  // console.log("createSourceParams", createSourceParams);
+  let createSourceRole = new Set();
+  const reformCreateSourceParams = {};
+
+  for (const createSource of createSourceParams) {
+    const { roleName, additionalResourcePermission } =
+      createSource.templateData;
+
+    if (!roleName || !additionalResourcePermission) continue;
+
+    if (!reformCreateSourceParams[roleName]) {
+      reformCreateSourceParams[roleName] = { resourcePermissions: [] };
+    }
+
+    const rolePermissions =
+      reformCreateSourceParams[roleName].resourcePermissions;
+
+    for (const newPerm of additionalResourcePermission) {
+      const normalizedActions = Object.entries(newPerm.action)
+        .flatMap(([service, actions]) =>
+          actions.map(action => `${service}:${action}`)
+        )
+        .sort();
+
+      const effect = newPerm.effect;
+      const resources = [...new Set(newPerm.resource)];
+
+      const existing = rolePermissions.find(
+        permission =>
+          permission.effect === effect &&
+          JSON.stringify([...permission.action].sort()) ===
+            JSON.stringify(normalizedActions)
+      );
+
+      if (existing) {
+        // Merge resources (deduplicate with Set)
+        existing.resource = Array.from(
+          new Set([...existing.resource, ...resources])
+        );
+      } else {
+        // Push new permission
+        rolePermissions.push({
+          effect: effect,
+          action: normalizedActions,
+          resource: resources
+        });
+      }
+    }
+  }
+  // console.log({ reformCreateSourceParams: JSON.stringify(reformCreateSourceParams, null, 2) })
+  for (const [roleName, roleData] of Object.entries(reformCreateSourceParams)) {
+    createSourceRole.add({
+      templatePath: templatePath,
+      templateData: { roleName, roleData },
+      setting: {
+        initialData: 'Resources:\n',
+        savePath: path.join(srcPath, SOURCE_PATH.appYaml),
+        saveFileName: SAVE_FILE_NAME.sharedResourceYaml,
+        fileExtension: '.yml',
+        isAppend: true
+      }
+    });
+  }
+
+  return createSourceRole;
+}
+
+export default generateRole;

package/src/TemplateData/generateRole/sharedResourceTemplate.ejs

@@ -0,0 +1,32 @@
+#IAM Role for Upload Schema functionality
+<% if (roles && roles.length > 0) { -%>
+<% roles.forEach(function(role) { %>
+  <%= role.roleName %>Role:
+    Type: AWS::IAM::Role
+    Properties:
+      RoleName: ${self:custom.iz_resourcePrefix}<%= role.roleName %>Role
+      AssumeRolePolicyDocument:
+        Version: "2012-10-17"
+        Statement:
+          - Effect: Allow
+            Principal:
+              Service: "lambda.amazonaws.com"
+            Action: sts:AssumeRole
+      ManagedPolicyArns:
+        - arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
+      Policies:
+        - PolicyName: ${self:custom.iz_resourcePrefix}<%= role.roleName %>Policy
+          PolicyDocument:
+            Version: "2012-10-17"
+            Statement:<% role.rolePolicyStatement.forEach(function(statement) { %>
+              - Effect: <%= statement.Effect %><%_ if (Array.isArray(statement.Action)) { %>
+                Action:<% statement.Action.forEach(function(action) { %>
+                  - <%= action %><% }); %><% } else { %>Action: <%= statement.Action %><% } -%>
+                <% if (Array.isArray(statement.Resource)) { %>
+                Resource:<% statement.Resource.forEach(function(resource) { %>
+                  - <%= resource -%><% }); %><% } else { %>
+                Resource: <%= statement.Resource %><% } %><% }); %>
+                #<#<%- role.roleName %>AdditionalRole#>
+                #<#/<%- role.roleName %>AdditionalRole#>
+  <% }); %>
+<% } %>

package/src/TemplateData/generateRole/template.ejs

@@ -0,0 +1,33 @@
+  <%- roleName %>Role:
+    Type: AWS::IAM::Role
+    Properties:
+      RoleName: ${self:custom.iz_resourcePrefix}<%- roleName %>Role
+      AssumeRolePolicyDocument:
+        Version: "2012-10-17"
+        Statement:
+          - Effect: Allow
+            Principal:
+              Service: "lambda.amazonaws.com"
+            Action: sts:AssumeRole
+        #<#AssumeRolePolicyDocument<%- roleName %>Role#>
+        #<#/AssumeRolePolicyDocument<%- roleName %>Role#>
+      ManagedPolicyArns:
+        - arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
+      Policies:
+        - PolicyName: ${self:custom.iz_resourcePrefix}<%- roleName %>Policy
+          PolicyDocument:
+            Version: "2012-10-17"
+            Statement:
+            <%_ roleData.resourcePermissions.forEach(resourcePermission => { _%>
+              - Effect: <%- resourcePermission.effect %>
+                Action:
+                <%_ resourcePermission.action.forEach(action => { _%>
+                - <%- action %>
+                <%_ }) _%>
+                Resource:
+                <%_ resourcePermission.resource.forEach(resource => { _%>
+                - "<%- resource %>"
+                <%_ }) _%>
+              <%_ }) _%>
+                #<#<%- roleName %>Role#>
+                #<#/<%- roleName %>Role#>

package/src/TemplateData/perActionComplete/create/handler/data.js

@@ -0,0 +1,61 @@
+/*
+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 path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+import { consts, utils } from '../../../../../MainLibs/index.js';
+
+const { HANDLER, SOURCE_PATH, FUNCTION_NAME } = consts;
+
+const { firstLetterLowerCase: lowerCase, firstLetterUpperCase: upperCase } =
+  utils;
+
+const templatePath = path.join(__dirname, 'template.ejs');
+
+/**
+ * receive objectSchema
+ * create data for hdrInv template
+ *
+ * @return {{ templatePath, templateData, setting } }
+ */
+function data(_izContext, srcPath) {
+  const createSourceParams = createParamForCreateSource(srcPath);
+  return [createSourceParams];
+}
+
+function createParamForCreateSource(srcPath) {
+  const functionName = FUNCTION_NAME.createObjectComplete;
+
+  return {
+    templatePath: templatePath,
+    templateData: {
+      functionName,
+      queueName: upperCase(functionName),
+      functionName
+    },
+    setting: {
+      savePath: path.join(srcPath, SOURCE_PATH.outPerActionComplete),
+      saveFileName: `${upperCase(functionName)}_${upperCase(HANDLER.hdrSqs)}`,
+      fileExtension: '.js',
+      isAppend: false
+    }
+  };
+}
+
+export default data;