@izara_project/izara-market-library-service-schemas 1.0.82 → 1.0.84

package/src/MainLibs/src/GenerateCodeUtils.js

@@ -15,13 +15,15 @@ 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';
-
 import { objectHash as hash } from '@izara_project/izara-shared-core';
 import utils from './Utils.js';
 const { firstLetterUpperCase: upperCase } = utils;
 
-function checkValidTableYaml(_izContext, currentTableSetting, existsTableSetting) {
+function checkValidTableYaml(
+  _izContext,
+  currentTableSetting,
+  existsTableSetting
+) {
   // console.log("checkValidTableYaml", JSON.stringify(currentTableSetting, null, 2), JSON.stringify(existsTableSetting, null, 2))
   /*
     return table yml setting that already filter duplicate tableName that have same table setting
@@ -33,25 +35,33 @@ function checkValidTableYaml(_izContext, currentTableSetting, existsTableSetting
   for (let i = 0, length = currentTableSetting.length; i < length; i++) {
     let dynamoDbYamlSetting = currentTableSetting[i];
     // console.log("dynamoDbYamlSetting", dynamoDbYamlSetting)
-    if (existsTableSetting.hasOwnProperty(upperCase(dynamoDbYamlSetting.templateData.tableName))) {
-
+    if (
+      existsTableSetting.hasOwnProperty(
+        upperCase(dynamoDbYamlSetting.templateData.tableName)
+      )
+    ) {
       // exists table
-      if (hash(existsTableSetting[upperCase(dynamoDbYamlSetting.templateData.tableName)]) === hash(dynamoDbYamlSetting.templateData.attributes.sort())) {
+      if (
+        hash(
+          existsTableSetting[
+            upperCase(dynamoDbYamlSetting.templateData.tableName)
+          ]
+        ) === hash(dynamoDbYamlSetting.templateData.attributes.sort())
+      ) {
         continue;
       } else {
-        throw Error(`tableName:${upperCase(dynamoDbYamlSetting.templateData.tableName)} have duplicate setting but not have same setting`)
+        throw Error(
+          `tableName:${upperCase(dynamoDbYamlSetting.templateData.tableName)} have duplicate setting but not have same setting`
+        );
       }
-
     } else {
       filteredDynamoDbYamlSetting.push(dynamoDbYamlSetting);
 
       // not exists table
-      Object.assign(
-        existsTableSetting,
-        {
-          [upperCase(dynamoDbYamlSetting.templateData.tableName)]: dynamoDbYamlSetting.templateData.attributes.sort()
-        }
-      );
+      Object.assign(existsTableSetting, {
+        [upperCase(dynamoDbYamlSetting.templateData.tableName)]:
+          dynamoDbYamlSetting.templateData.attributes.sort()
+      });
     }
   }
   // console.log("filteredDynamoDbYamlSetting: ", JSON.stringify(filteredDynamoDbYamlSetting, null, 2),
@@ -59,4 +69,4 @@ function checkValidTableYaml(_izContext, currentTableSetting, existsTableSetting
   return [filteredDynamoDbYamlSetting, existsTableSetting];
 }
 
-export default checkValidTableYaml;
+export default checkValidTableYaml;

package/src/MainLibs/src/Utils.js

@@ -15,37 +15,41 @@ 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';
-
 import yaml from 'yaml';
-import fs from "fs";
+import fs from 'fs';
 import path from 'path';
 
 function firstLetterUpperCase(text) {
-  return text.charAt(0).toUpperCase() + text.slice(1)
+  return text.charAt(0).toUpperCase() + text.slice(1);
 }
 
 function firstLetterLowerCase(str) {
-  return str.charAt(0).toLowerCase() + str.slice(1)
+  return str.charAt(0).toLowerCase() + str.slice(1);
 }
 
 function checkOverWriteGenerateMainFunction(objectSchema, action) {
   let overWriteStatus;
-  if (objectSchema.overwriteGenerateMainFunction?.length && objectSchema.overwriteGenerateMainFunction.includes(action)) {
-    overWriteStatus = true
+  if (
+    objectSchema.overwriteGenerateMainFunction?.length &&
+    objectSchema.overwriteGenerateMainFunction.includes(action)
+  ) {
+    overWriteStatus = true;
   } else {
-    overWriteStatus = false
+    overWriteStatus = false;
   }
-  return overWriteStatus
+  return overWriteStatus;
 }
 
 function getLocalConfig(params) {
-  const configPath = path.join(process.cwd(), '../config/serverless.config.yml');
+  const configPath = path.join(
+    process.cwd(),
+    '../config/serverless.config.yml'
+  );
   const serverlessConfig = fs.readFileSync(configPath, 'utf8');
   const config = yaml.parse(serverlessConfig);
   const returnConfig = config.main_config[params];
 
-  return returnConfig
+  return returnConfig;
 }
 
 // module.exports.renameObjectType = (objectSchema, srcPath) => {
@@ -65,4 +69,4 @@ export default {
   firstLetterLowerCase,
   checkOverWriteGenerateMainFunction,
   getLocalConfig
-}
+};

package/src/SourceManager/index.js

@@ -15,11 +15,7 @@ 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';
-import utils from './src/Utils.js'
-import createSource from './src/CreateSource.js'
+import utils from './src/Utils.js';
+import createSource from './src/CreateSource.js';
 
-export {
-  utils,
-  createSource
-}
+export { utils, createSource };

package/src/SourceManager/src/CreateSource.js

@@ -15,25 +15,21 @@ 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';
-
-
 import fs from 'fs';
 import ejs from 'ejs';
 import { join } from 'path';
 import beautify from 'js-beautify/js/index.js';
 
-
 const beautifySetting = {
-  "indent_size": "2",
-  "indent_char": " ",
-  "max_preserve_newlines": "0",
+  indent_size: '2',
+  indent_char: ' ',
+  max_preserve_newlines: '0',
   // "preserve_newlines": true,
-  "keep_array_indentation": true,
-  "indent_scripts": "separate",
-  "brace_style": ["preserve-inline", "none"],
-  "space_before_conditional": true,
-}
+  keep_array_indentation: true,
+  indent_scripts: 'separate',
+  brace_style: ['preserve-inline', 'none'],
+  space_before_conditional: true
+};
 
 const TAG_CLASSES = {
   doubleTag: 'doubleTag',
@@ -45,33 +41,42 @@ const TAG_CLASSES = {
   ymlAnyDoubleTag: 'ymlAnyDoubleTag'
 };
 
-
 function tagList(tagClass = TAG_CLASSES.singleTag, tagName) {
   return {
     // return regex depend on tagClass
     [TAG_CLASSES.singleTag]: new RegExp(`\/\/\\(<${tagName}>\\)`, 'gm'), // match //(<tagName>)
-    [TAG_CLASSES.doubleTag]: new RegExp(`\/\/\\(<${tagName}>\\)([\\s\\S]*?)\/\/\\(<\\/${tagName}>\\)`, 'gm'), // get data between tag -> //(<tagName>) data //(</tagName>)
+    [TAG_CLASSES.doubleTag]: new RegExp(
+      `\/\/\\(<${tagName}>\\)([\\s\\S]*?)\/\/\\(<\\/${tagName}>\\)`,
+      'gm'
+    ), // get data between tag -> //(<tagName>) data //(</tagName>)
     [TAG_CLASSES.nameTag]: new RegExp(`__${tagName}`, 'gm'), // match //(<tagName>)
     [TAG_CLASSES.anyTag]: new RegExp(`\/\/\\(<([^>]+)>\\)`, 'g'), // match //(<anyname>)
-    [TAG_CLASSES.anyDoubleTag]: new RegExp('\/\/\\(<(\\w+)>\\)([\\s\\S]*?)\/\/\\(<\/\\1>\\)', 'gm'),
-    [TAG_CLASSES.ymlDoubleTag]: new RegExp(`\#<#${tagName}#>([\\s\\S]*?)#<#\/${tagName}#>`, 'gm'), // match #<#tag#> #<#/tag#>
-    [TAG_CLASSES.ymlAnyDoubleTag]: new RegExp(`\#<#(\\w+)#>([\\s\\S]*?)#<#\/\\1#>`, 'gm'), // get tagName from  doubleTag #<#tagName#> #<#/tagName#>
-  }[tagClass]
+    [TAG_CLASSES.anyDoubleTag]: new RegExp(
+      '\/\/\\(<(\\w+)>\\)([\\s\\S]*?)\/\/\\(<\/\\1>\\)',
+      'gm'
+    ),
+    [TAG_CLASSES.ymlDoubleTag]: new RegExp(
+      `\#<#${tagName}#>([\\s\\S]*?)#<#\/${tagName}#>`,
+      'gm'
+    ), // match #<#tag#> #<#/tag#>
+    [TAG_CLASSES.ymlAnyDoubleTag]: new RegExp(
+      `\#<#(\\w+)#>([\\s\\S]*?)#<#\/\\1#>`,
+      'gm'
+    ) // get tagName from  doubleTag #<#tagName#> #<#/tagName#>
+  }[tagClass];
 }
 
-
 /**
  *
  * @param {string} template
  * @param {object} data
  * @returns
  */
-function generateDataFromTemplate(template, data,) {
+function generateDataFromTemplate(template, data) {
   let dataToSave = ejs.compile(template)(data);
   return dataToSave;
 }
 
-
 /**
  * generate code from template and data then save generated data
  *
@@ -86,10 +91,21 @@ function generateDataFromTemplate(template, data,) {
  * @param {string} setting.initialData // initialData can use when isAppend = true
  * @returns
  */
-async function createSource(template, data, { savePath, hookPath, saveFileName, fileExtension, initialData, isAppend = false, checkCreateSourcePass = false, generateHookFile = true }) {
-
+async function createSource(
+  template,
+  data,
+  {
+    savePath,
+    hookPath,
+    saveFileName,
+    fileExtension,
+    initialData,
+    isAppend = false,
+    checkCreateSourcePass = false,
+    generateHookFile = true
+  }
+) {
   try {
-
     if (checkCreateSourcePass) {
       try {
         generateDataFromTemplate(template, data);
@@ -99,11 +115,10 @@ async function createSource(template, data, { savePath, hookPath, saveFileName,
       }
     }
 
-
     let dataToSave = generateDataFromTemplate(template, data);
 
-    let anyDoubleTagClass
-    let doubleTagClass
+    let anyDoubleTagClass;
+    let doubleTagClass;
 
     if (fileExtension === '.js') {
       anyDoubleTagClass = TAG_CLASSES.anyDoubleTag;
@@ -115,56 +130,100 @@ async function createSource(template, data, { savePath, hookPath, saveFileName,
     let hookDataPath = hookPath ? hookPath : join(savePath, '../hook/');
 
     if (!fs.existsSync(savePath)) fs.mkdirSync(savePath, { recursive: true });
-    if (generateHookFile) if (!fs.existsSync(hookDataPath)) fs.mkdirSync(hookDataPath, { recursive: true });
+    if (generateHookFile)
+      if (!fs.existsSync(hookDataPath))
+        fs.mkdirSync(hookDataPath, { recursive: true });
 
     // check saveFileName for Hook exists
-    if (fs.existsSync(`${hookDataPath}${saveFileName}${fileExtension}`.trim())) {
-      const hookData = fs.readFileSync(`${hookDataPath}${saveFileName}${fileExtension}`, 'utf8');
+    if (
+      fs.existsSync(`${hookDataPath}${saveFileName}${fileExtension}`.trim())
+    ) {
+      const hookData = fs.readFileSync(
+        `${hookDataPath}${saveFileName}${fileExtension}`,
+        'utf8'
+      );
 
       //replace data in tag from hook file to actual file
-      let dataAfterHook = dataToSave.replace(tagList(anyDoubleTagClass), (match, tagName, content) => {
-        let hookRegex = tagList(doubleTagClass, tagName);
-        let replaceData = hookData.match(hookRegex);
-
-        if (replaceData) {
-          return replaceData;
-        } else {
-          return match;
+      let dataAfterHook = dataToSave.replace(
+        tagList(anyDoubleTagClass),
+        (match, tagName, content) => {
+          let hookRegex = tagList(doubleTagClass, tagName);
+          let replaceData = hookData.match(hookRegex);
+
+          if (replaceData) {
+            return replaceData;
+          } else {
+            return match;
+          }
         }
-      });
+      );
 
-      dataAfterHook = fileExtension === '.js' ? beautify(dataAfterHook, beautifySetting) : dataAfterHook
+      dataAfterHook =
+        fileExtension === '.js'
+          ? beautify(dataAfterHook, beautifySetting)
+          : dataAfterHook;
       if (isAppend) {
-        if (!fs.existsSync(`${savePath}${saveFileName}${fileExtension}`) && initialData) {
-          fs.writeFileSync(`${savePath}${saveFileName}${fileExtension}`.trim(), initialData + dataAfterHook + '\n\n', 'utf8');
+        if (
+          !fs.existsSync(`${savePath}${saveFileName}${fileExtension}`) &&
+          initialData
+        ) {
+          fs.writeFileSync(
+            `${savePath}${saveFileName}${fileExtension}`.trim(),
+            initialData + dataAfterHook + '\n\n',
+            'utf8'
+          );
         } else {
-          fs.appendFileSync(`${savePath}${saveFileName}${fileExtension}`.trim(), dataAfterHook + '\n\n', 'utf8');
+          fs.appendFileSync(
+            `${savePath}${saveFileName}${fileExtension}`.trim(),
+            dataAfterHook + '\n\n',
+            'utf8'
+          );
         }
       } else {
-        fs.writeFileSync(`${savePath}${saveFileName}${fileExtension}`.trim(), dataAfterHook, 'utf8');
+        fs.writeFileSync(
+          `${savePath}${saveFileName}${fileExtension}`.trim(),
+          dataAfterHook,
+          'utf8'
+        );
       }
-
     } else {
-      dataToSave = fileExtension === '.js' ? beautify(dataToSave, beautifySetting) : dataToSave
+      dataToSave =
+        fileExtension === '.js'
+          ? beautify(dataToSave, beautifySetting)
+          : dataToSave;
       if (isAppend) {
-        if (!fs.existsSync(`${savePath}${saveFileName}${fileExtension}`) && initialData) {
-          fs.writeFileSync(`${savePath}${saveFileName}${fileExtension}`.trim(), initialData + dataToSave + '\n\n', 'utf8');
+        if (
+          !fs.existsSync(`${savePath}${saveFileName}${fileExtension}`) &&
+          initialData
+        ) {
+          fs.writeFileSync(
+            `${savePath}${saveFileName}${fileExtension}`.trim(),
+            initialData + dataToSave + '\n\n',
+            'utf8'
+          );
         } else {
-          fs.appendFileSync(`${savePath}${saveFileName}${fileExtension}`.trim(), dataToSave + '\n\n', 'utf8');
+          fs.appendFileSync(
+            `${savePath}${saveFileName}${fileExtension}`.trim(),
+            dataToSave + '\n\n',
+            'utf8'
+          );
         }
       } else {
-        fs.writeFileSync(`${savePath}${saveFileName}${fileExtension}`.trim(), dataToSave, 'utf8');
+        fs.writeFileSync(
+          `${savePath}${saveFileName}${fileExtension}`.trim(),
+          dataToSave,
+          'utf8'
+        );
       }
     }
 
     return;
-
   } catch (err) {
-    console.log('error createSource: ', err);// generate
-    throw (err)
+    console.log('error createSource: ', err); // generate
+    throw err;
   }
 }
 export default {
   createSource,
   generateDataFromTemplate
-}
+};

package/src/SourceManager/src/Utils.js

@@ -15,19 +15,15 @@ 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';
-
-
 import fs from 'fs';
-import path from 'path';;
+import path from 'path';
 import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);;
+const __dirname = path.dirname(__filename);
 import utils from '../../MainLibs/src/Utils.js';
-const { firstLetterUpperCase: upperCase } = utils
+const { firstLetterUpperCase: upperCase } = utils;
 // const { unlink, readdir } = require('node:fs/promises');
 
-
 // empty dir
 async function deleteFileInDir(directory) {
   try {
@@ -53,48 +49,55 @@ function deleteFile(filePath) {
   }
 }
 
+async function createHookFunction(
+  _izContext,
+  sourcePath,
+  setting = { fileExtension, isAppend, saveFileName, destinationPath }
+) {
+  _izContext.logger.debug('createHookFunction', { sourcePath, setting });
 
-async function createHookFunction(_izContext, sourcePath, setting = { fileExtension, isAppend, saveFileName, destinationPath }) {
-  _izContext.logger.debug("createHookFunction", { sourcePath, setting });
-
-  let absSourcePath = path.resolve("src/schemas/flowSchema", sourcePath);
-  let absDestinationPath = path.resolve(setting.destinationPath, upperCase(setting.saveFileName) + (setting?.fileExtension || ".js"));
+  let absSourcePath = path.resolve('src/schemas/flowSchema', sourcePath);
+  let absDestinationPath = path.resolve(
+    setting.destinationPath,
+    upperCase(setting.saveFileName) + (setting?.fileExtension || '.js')
+  );
 
-  _izContext.logger.debug("Source:", absSourcePath);
-  _izContext.logger.debug("Destination:", absDestinationPath);
+  _izContext.logger.debug('Source:', absSourcePath);
+  _izContext.logger.debug('Destination:', absDestinationPath);
 
   if (!fs.existsSync(absSourcePath)) {
-    _izContext.logger.debug("Source file does not exist:");
+    _izContext.logger.debug('Source file does not exist:');
     return;
   }
 
   const destDir = path.dirname(absDestinationPath);
   if (!fs.existsSync(destDir)) {
-    _izContext.logger.debug("Destination directory missing. Creating...");
+    _izContext.logger.debug('Destination directory missing. Creating...');
     fs.mkdirSync(destDir, { recursive: true });
   }
 
   try {
     await fs.promises.copyFile(absSourcePath, absDestinationPath);
-    _izContext.logger.debug("File copied successfully!");
+    _izContext.logger.debug('File copied successfully!');
 
     if (fs.existsSync(absDestinationPath)) {
-      _izContext.logger.debug("File exists after copying:", absDestinationPath);
+      _izContext.logger.debug('File exists after copying:', absDestinationPath);
     } else {
-      _izContext.logger.debug("File still missing after copying: ", absDestinationPath);
+      _izContext.logger.debug(
+        'File still missing after copying: ',
+        absDestinationPath
+      );
     }
   } catch (err) {
-    _izContext.logger.debug("Error copying file:", err);
+    _izContext.logger.debug('Error copying file:', err);
   }
 }
 
-
 export default {
   deleteFileInDir,
   deleteFile,
   createHookFunction
-}
-
+};
 
 // remove file
 // async function deleteFileInDir(directory) {

package/src/reStructure/GenerateCode.js

@@ -15,27 +15,29 @@ 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';
-
-import { join, dirname } from "path";
+import { join, dirname } from 'path';
 import { fileURLToPath, pathToFileURL } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
-import { readFileSync } from "fs";
+import { readFileSync } from 'fs';
 
-import { validatePathWithRootServicePath } from "./libs/GenerateCodeLibs.js";
+import { validatePathWithRootServicePath } from './libs/GenerateCodeLibs.js';
 
-import { templateConfig } from "./TemplateConfig.js";
+import { templateConfig } from './TemplateConfig.js';
 // SourceManager
-import { utils, createSource } from "../SourceManager/index.js";
-const { deleteFileInDir } = utils
+import { utils, createSource } from '../SourceManager/index.js';
+const { deleteFileInDir } = utils;
 
 //* get functionNameConfig
 import functionNameConfigYamlData from './TemplateData/externalService/functionNameConfig/data.js';
 import generateRole from './TemplateData/generateRole/data.js';
 
-async function generateCodeWithTemplate(_izContext, objSchemaPath, settings = {}) {
+async function generateCodeWithTemplate(
+  _izContext,
+  objSchemaPath,
+  settings = {}
+) {
   try {
     // console.log('objSchemaPath', objSchemaPath);
     // ---------  Prepare path  -------------
@@ -43,7 +45,7 @@ async function generateCodeWithTemplate(_izContext, objSchemaPath, settings = {}
     let saveFilePath = join(objSchemaPath, `../`);
 
     // point to root folder of service
-    let localServicePath = join(saveFilePath, "../../");
+    let localServicePath = join(saveFilePath, '../../');
 
     // // define path for store yml file
     // const GENERATE_CODE_SOURCE_PATH = {
@@ -61,30 +63,51 @@ async function generateCodeWithTemplate(_izContext, objSchemaPath, settings = {}
     //------ Start Create Source ------
 
     // collect all result of template data for execute createSource
-    let allCreateSource = []
+    let allCreateSource = [];
 
     // * iterate templateConfig for generate data
     for (const templateName in templateConfig.TemplateAndData) {
       // Display log indicating which template is being loaded
-      let generateTemplateData = (await import(join(__dirname, templateConfig.TemplateAndData[templateName]))).default;
+      let generateTemplateData = (
+        await import(
+          join(__dirname, templateConfig.TemplateAndData[templateName])
+        )
+      ).default;
       // sources[eventSourceTag] = await import(`../MiddlewareCore/EventSources/${eventSourceTag}.js`);
-      let createSourceResult = await generateTemplateData(_izContext, objSchemaPath, settings);
+      let createSourceResult = await generateTemplateData(
+        _izContext,
+        objSchemaPath,
+        settings
+      );
 
       // Filter out empty or invalid objects before adding to allCreateSource
       if (Array.isArray(createSourceResult)) {
-        const validResults = createSourceResult.filter(item =>
-          item && item.templatePath && item.templateData && item.setting
+        const validResults = createSourceResult.filter(
+          item => item && item.templatePath && item.templateData && item.setting
         );
         allCreateSource.push(...validResults);
       }
     }
 
     // ** Generate function name configuration
-    const functionNameConfigs = functionNameConfigYamlData(_izContext, allCreateSource, saveFilePath);
+    const functionNameConfigs = functionNameConfigYamlData(
+      _izContext,
+      allCreateSource,
+      saveFilePath
+    );
     allCreateSource.push(...functionNameConfigs);
 
-    let filterAllCreateSource = allCreateSource.filter((createSource) => createSource.templateData.hasOwnProperty("additionalResourcePermission") && createSource.templateData.hasOwnProperty("roleName"))
-    const generateRoleData = generateRole(_izContext, filterAllCreateSource, saveFilePath);
+    let filterAllCreateSource = allCreateSource.filter(
+      createSource =>
+        createSource.templateData.hasOwnProperty(
+          'additionalResourcePermission'
+        ) && createSource.templateData.hasOwnProperty('roleName')
+    );
+    const generateRoleData = generateRole(
+      _izContext,
+      filterAllCreateSource,
+      saveFilePath
+    );
     allCreateSource.push(...generateRoleData);
 
     // ** create Generate-Shared-resource
@@ -100,7 +123,6 @@ async function generateCodeWithTemplate(_izContext, objSchemaPath, settings = {}
         throw Error('Skipping invalid source item:', item);
       }
 
-
       const { templatePath, templateData, setting } = item;
       setting.checkCreateSourcePass = true;
       // console.log({ templatePath })
@@ -108,20 +130,19 @@ async function generateCodeWithTemplate(_izContext, objSchemaPath, settings = {}
       let [status, errors] = await createSource.createSource(
         readFileSync(templatePath, 'utf8'),
         templateData,
-        setting,
+        setting
       );
 
       if (status === false) {
         // console.log('templatePath in generateCode', templatePath)
-        throw Error(errors)
+        throw Error(errors);
       }
 
       // console.log("templatePath in generateCode", setting.savePath)
       // empty file by savePath
       // validate path before empty folder
-      validatePathWithRootServicePath(localServicePath, setting.savePath)
+      validatePathWithRootServicePath(localServicePath, setting.savePath);
       await deleteFileInDir(setting.savePath);
-
     }
 
     // generate all source
@@ -138,7 +159,7 @@ async function generateCodeWithTemplate(_izContext, objSchemaPath, settings = {}
       await createSource.createSource(
         readFileSync(templatePath, 'utf8'),
         templateData,
-        setting,
+        setting
       );
     }
 
@@ -150,9 +171,7 @@ async function generateCodeWithTemplate(_izContext, objSchemaPath, settings = {}
   }
 }
 
-export default generateCodeWithTemplate
-
-
+export default generateCodeWithTemplate;
 
 /*
   GenerateCode will iterate through templateConfig and generate each template dependOn each templateAndData\
@@ -162,4 +181,4 @@ export default generateCodeWithTemplate
     when generateSchema in own service need to generate ref objectRelationship only
     and attribute tree service can generate schema
 
-*/
+*/