@izara_project/izara-core-generate-service-code 1.0.53 → 1.0.55

package/src/generateCode.js

@@ -5,17 +5,17 @@ import { parseObjectSchemas } from './parsers/objectSchemaParser.js';
 import { parseRelationshipSchemas } from './parsers/relationshipSchemaParser.js';
 import { parseFlowSchemas } from './parsers/flowSchemaParser.js';
 
-import { buildSystemFlowDescriptors } from './codeGenerators/app/src/generatedCode/Flow/SystemFlowDescriptorBuilder.js';
+import { generateFlowEntryPoint } from './codeGenerators/app/src/generatedCode/Flow/_shared/shared/flowEntryPointBase.js';
+import { generateFlowMainFunction } from './codeGenerators/app/src/generatedCode/Flow/_shared/shared/flowMainFunctionBase.js';
+import { generateFlowSteps } from './codeGenerators/app/src/generatedCode/Flow/_shared/shared/flowStepBase.js';
 
-import { generateFlowEntryPoint } from './codeGenerators/app/src/generatedCode/Flow/_internal/shared/flowEntryPointBase.js';
-import { generateFlowMainFunction } from './codeGenerators/app/src/generatedCode/Flow/_internal/shared/flowMainFunctionBase.js';
-import { generateFlowSteps } from './codeGenerators/app/src/generatedCode/Flow/_internal/shared/flowStepBase.js';
+import { generateEndpointsFlow } from './codeGenerators/app/src/generatedCode/Flow/FlowEndpoints/EndpointsGenerator.js';
 import { generateFlowOut } from './codeGenerators/resource/sls_yaml/FlowOutGenerator.js';
 import { generateFlowResourceYaml } from './codeGenerators/resource/sls_yaml/FlowResourceYamlGenerator.js';
 import { generateRbacFlows } from './codeGenerators/app/src/generatedCode/Flow/FlowRbac/RbacFlowGenerator.js';
 import { generateRelationshipFlows } from './codeGenerators/app/src/generatedCode/Flow/FlowRelationshipEndpoints/RelationshipFlowGenerator.js';
 import { generateWebSocket } from './codeGenerators/app/src/generatedCode/Flow/FlowSchemas/WebSocketGenerator.js';
-import { validateFlowsForGeneration } from './codeGenerators/app/src/generatedCode/Flow/_internal/shared/flowValidator.js';
+import { validateFlowsForGeneration } from './codeGenerators/app/src/generatedCode/Flow/_shared/shared/flowValidator.js';
 import { generateRegisterFlow } from './codeGenerators/app/src/generatedCode/SystemFlowSchemas/RegisterGenerator.js';
 import { generateDynamoDBTables } from './codeGenerators/resource/sls_yaml/DynamoDBGenerator.js';
 import { generateFindData } from './codeGenerators/app/src/generatedCode/FindData/FindDataGenerator.js';
@@ -27,47 +27,108 @@ import { generateConsts } from './codeGenerators/app/src/generatedCode/libs/Cons
 import { generateProcessLogical } from './codeGenerators/app/src/generatedCode/ProcessLogical/ProcessLogicalGenerator.js';
 import { generateProcessLogicalYaml } from './codeGenerators/app/sls_yaml/ProcessLogicalYamlGenerator.js';
 import { generateSharedResourceYaml } from './codeGenerators/app/sls_yaml/SharedResourceYamlGenerator.js';
+import { generateFindDataYaml } from './codeGenerators/app/sls_yaml/FindDataYamlGenerator.js';
 import { policyRegistry } from './codeGenerators/app/sls_yaml/_policy/PolicyRegistry.js';
 import { emitManagedPolicies } from './codeGenerators/app/sls_yaml/_policy/PolicyEmitter.js';
 
-export async function generateCode(rootPath, options) {
+function createGeneratorOptions(rootPath, options = {}) {
+  return {
+    outputPath: options.outputPath || rootPath
+  };
+}
+
+export async function generateCode(rootPath, options = {}) {
   console.log(
     '[INFO] [generateCode] STATUS=STARTING | Generating code files from all schemas...'
   );
 
+  const generatorOptions = createGeneratorOptions(rootPath, options);
+  const { outputPath } = generatorOptions;
+
   // Clean workspace
-  const outputPath = options.outputPath || rootPath;
-  const generatedCodePath = path.join(outputPath, 'app', 'src', 'generatedCode');
+  const generatedCodePath = path.join(
+    outputPath,
+    'app',
+    'src',
+    'generatedCode'
+  );
 
   // Backup existing hook files to prevent them from being wiped out
   const hookBackups = [];
-  function backupHooks(currentDir) {
+  const hookDirs = new Set();
+
+  function getHookTagMatchers(filePath) {
+    if (filePath.endsWith('.js')) {
+      return {
+        anyTag: /\/\/\(<(\w+)>\)([\s\S]*?)\/\/\(<\/\1>\)/gm,
+        tagPattern: name =>
+          new RegExp(
+            `\\/\\/\\(<${name}>\\)([\\s\\S]*?)\\/\\/\\(<\\/${name}>\\)`,
+            'gm'
+          )
+      };
+    }
+
+    if (filePath.endsWith('.yml') || filePath.endsWith('.yaml')) {
+      return {
+        anyTag: /#<#(\w+)#>([\s\S]*?)#<#\/\1#>/gm,
+        tagPattern: name =>
+          new RegExp(`#<#${name}#>([\\s\\S]*?)#<#\\/${name}#>`, 'gm')
+      };
+    }
+
+    return null;
+  }
+
+  function mergeHookIntoSource(sourceContent, hookContent, filePath) {
+    const matchers = getHookTagMatchers(filePath);
+    if (!matchers) return hookContent;
+
+    return sourceContent.replace(
+      matchers.anyTag,
+      (match, tagName) =>
+        hookContent.match(matchers.tagPattern(tagName))?.[0] ?? match
+    );
+  }
+
+  function collectHookBackups(currentDir) {
     if (!fs.existsSync(currentDir)) return;
+
     const items = fs.readdirSync(currentDir, { withFileTypes: true });
+    const hasSource = items.some(
+      item => item.isDirectory() && item.name === 'source'
+    );
+    const hasHook = items.some(
+      item => item.isDirectory() && item.name === 'hook'
+    );
 
-    for (const item of items) {
-      if (item.isDirectory()) {
-        if (item.name === 'hook') {
-          const hookPath = path.join(currentDir, 'hook');
-          const hookItems = fs.readdirSync(hookPath, { withFileTypes: true });
-          for (const hookItem of hookItems) {
-            if (hookItem.isFile()) {
-              hookBackups.push({
-                relativePath: path.relative(generatedCodePath, hookPath),
-                name: hookItem.name,
-                content: fs.readFileSync(path.join(hookPath, hookItem.name))
-              });
-            }
-          }
-        } else if (item.name !== 'source') {
-          backupHooks(path.join(currentDir, item.name));
-        }
+    if (hasSource && hasHook) {
+      const hookPath = path.join(currentDir, 'hook');
+      hookDirs.add(path.relative(outputPath, hookPath));
+      const hookItems = fs.readdirSync(hookPath, { withFileTypes: true });
+
+      for (const hookItem of hookItems) {
+        if (!hookItem.isFile()) continue;
+        const hookFilePath = path.join(hookPath, hookItem.name);
+        hookBackups.push({
+          relativePath: path.relative(outputPath, hookPath),
+          name: hookItem.name,
+          content: fs.readFileSync(hookFilePath)
+        });
       }
     }
+
+    for (const item of items) {
+      if (!item.isDirectory() || item.name === 'source' || item.name === 'hook')
+        continue;
+      collectHookBackups(path.join(currentDir, item.name));
+    }
   }
-  
-  console.log('[INFO] [generateCode] STATUS=BACKUP | Backing up existing hook files...');
-  backupHooks(generatedCodePath);
+
+  console.log(
+    '[INFO] [generateCode] STATUS=BACKUP | Backing up existing hook files...'
+  );
+  collectHookBackups(outputPath);
 
   console.log(
     '[INFO] [generateCode] STATUS=CLEANUP | Removing old generatedCode and resource directories...'
@@ -97,38 +158,19 @@ export async function generateCode(rootPath, options) {
   console.log('[INFO] [generateCode] STATUS=PARSING | FlowSchemas...');
   const flowData = await parseFlowSchemas(rootPath, objectData, options);
 
-  // Build fixed system flows in memory instead of writing generated FlowSchema files.
-  const systemFlowData = buildSystemFlowDescriptors(
-    objectData,
-    relationshipData,
-    flowData
-  );
-
   // The 'allSchemas' object contains the fully hydrated Memory Objects
   const allSchemas = {
     objects: objectData.objects,
     relationships: relationshipData.relationships,
     flows: flowData.flows,
-    systemFlows: systemFlowData.flows,
-    flowsForGeneration: [
-      ...(flowData.flows || []),
-      ...(systemFlowData.flows || [])
-    ]
+    flowsForGeneration: flowData.flows || []
   };
 
-  // DEBUG: Dump the hydrated allSchemas to a file so we can inspect it
-  const dumpPath = path.join(
-    options.outputPath || rootPath,
-    'allSchemas_debug.json'
-  );
-  fs.writeFileSync(dumpPath, JSON.stringify(allSchemas, null, 2));
-
   console.log('[INFO] [generateCode] STATUS=VALIDATING | Validating Flows...');
   validateFlowsForGeneration(allSchemas.flowsForGeneration);
 
-  const generatorOptions = { outputPath: options.outputPath || rootPath };
-
   // 2. Generation Pipeline
+  await generateEndpointsFlow(allSchemas, generatorOptions);
   await generateFlowMainFunction(allSchemas, generatorOptions);
   await generateFlowEntryPoint(allSchemas, generatorOptions);
   await generateFlowSteps(allSchemas, generatorOptions);
@@ -136,11 +178,19 @@ export async function generateCode(rootPath, options) {
   await generateFlowResourceYaml(allSchemas, generatorOptions);
   await generateRbacFlows(allSchemas, generatorOptions);
   await generateRelationshipFlows(allSchemas, generatorOptions);
-  await generateWebSocket(allSchemas.flowsForGeneration, '', generatorOptions.outputPath);
-  await generateRegisterFlow(allSchemas.flowsForGeneration, '', generatorOptions.outputPath);
+  await generateWebSocket(
+    allSchemas.flowsForGeneration,
+    '',
+    generatorOptions.outputPath
+  );
+  await generateRegisterFlow(
+    allSchemas.flowsForGeneration,
+    '',
+    generatorOptions.outputPath
+  );
 
   // Call FunctionYamlGenerator after all Handlers have been generated
-  await generateFunctionYaml(allSchemas, options);
+  await generateFunctionYaml(allSchemas, generatorOptions);
   await generateDynamoDBTables(allSchemas, generatorOptions);
   await generateFindData(allSchemas, generatorOptions);
   await generateCodeLibs(generatorOptions);
@@ -148,6 +198,7 @@ export async function generateCode(rootPath, options) {
   await generateProcessLogical(generatorOptions);
   await generateRoleNameConfig(allSchemas, generatorOptions);
   await generateProcessLogicalYaml(allSchemas, generatorOptions);
+  await generateFindDataYaml(generatorOptions);
   await generateSharedResourceYaml(allSchemas, generatorOptions);
   await generateInitialSetup(allSchemas, generatorOptions);
 
@@ -158,51 +209,65 @@ export async function generateCode(rootPath, options) {
 
   function processSourceHooks(currentDir) {
     if (!fs.existsSync(currentDir)) return;
-    const items = fs.readdirSync(currentDir, { withFileTypes: true });
 
+    const items = fs.readdirSync(currentDir, { withFileTypes: true });
     const hasSource = items.some(
       item => item.isDirectory() && item.name === 'source'
     );
-    if (hasSource) {
+    const hasHook = items.some(
+      item => item.isDirectory() && item.name === 'hook'
+    );
+
+    if (hasSource && hasHook) {
       const sourcePath = path.join(currentDir, 'source');
       const hookPath = path.join(currentDir, 'hook');
+      const hookItems = fs.readdirSync(hookPath, { withFileTypes: true });
+
+      for (const hookItem of hookItems) {
+        if (!hookItem.isFile()) continue;
 
-      if (!fs.existsSync(hookPath)) {
-        fs.mkdirSync(hookPath, { recursive: true });
-      } else {
-        const hookItems = fs.readdirSync(hookPath, { withFileTypes: true });
-        for (const hookItem of hookItems) {
-          if (hookItem.isFile()) {
-            const srcFile = path.join(hookPath, hookItem.name);
-            const dstFile = path.join(sourcePath, hookItem.name);
-            fs.copyFileSync(srcFile, dstFile);
-            console.log(
-              `[INFO] [generateCode] HOOK APPLIED: Copied ${hookItem.name} to source.`
-            );
-          }
+        const hookFile = path.join(hookPath, hookItem.name);
+        const sourceFile = path.join(sourcePath, hookItem.name);
+
+        if (!fs.existsSync(sourceFile)) {
+          fs.copyFileSync(hookFile, sourceFile);
+          console.log(
+            `[INFO] [generateCode] HOOK APPLIED: Created ${hookItem.name} from hook.`
+          );
+          continue;
         }
+
+        const mergedContent = mergeHookIntoSource(
+          fs.readFileSync(sourceFile, 'utf8'),
+          fs.readFileSync(hookFile, 'utf8'),
+          sourceFile
+        );
+        fs.writeFileSync(sourceFile, mergedContent);
+        console.log(
+          `[INFO] [generateCode] HOOK APPLIED: Merged ${hookItem.name} into source.`
+        );
       }
+    } else if (hasSource) {
+      fs.mkdirSync(path.join(currentDir, 'hook'), { recursive: true });
     }
 
     for (const item of items) {
-      if (
-        item.isDirectory() &&
-        item.name !== 'source' &&
-        item.name !== 'hook'
-      ) {
-        processSourceHooks(path.join(currentDir, item.name));
-      }
+      if (!item.isDirectory() || item.name === 'source' || item.name === 'hook')
+        continue;
+      processSourceHooks(path.join(currentDir, item.name));
     }
   }
 
   // Restore backed-up hooks
-  if (hookBackups.length > 0) {
-    console.log(`[INFO] [generateCode] STATUS=RESTORE | Restoring ${hookBackups.length} hook files...`);
+  if (hookDirs.size > 0 || hookBackups.length > 0) {
+    console.log(
+      `[INFO] [generateCode] STATUS=RESTORE | Restoring ${hookBackups.length} hook files...`
+    );
+    for (const relativeHookDir of hookDirs) {
+      fs.mkdirSync(path.join(outputPath, relativeHookDir), { recursive: true });
+    }
     for (const backup of hookBackups) {
-      const hookDir = path.join(generatedCodePath, backup.relativePath);
-      if (!fs.existsSync(hookDir)) {
-        fs.mkdirSync(hookDir, { recursive: true });
-      }
+      const hookDir = path.join(outputPath, backup.relativePath);
       fs.writeFileSync(path.join(hookDir, backup.name), backup.content);
     }
   }

package/src/generateIntTest.js

@@ -1,5 +1,4 @@
-/*
-Copyright (C) 2020 Sven Mason <http://izara.io>
+/* 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
@@ -8,20 +7,20 @@ 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
+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/>.
+along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
-import { readFileSync, writeFileSync, appendFileSync, mkdirSync, existsSync, rmSync } from 'fs';
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
 import { join } from 'path';
-import yaml from 'yaml';
 import ejs from 'ejs';
 import beautify from 'js-beautify/js/index.js';
 
 import generateTestTemplate from './generateResources/IntTest/generateTests/generateTemplate.js';
+import { getServiceTag, runTemplateItems } from './intTestGeneratorShared.js';
 
 const BEAUTIFY_SETTING = {
   indent_size: '2',
@@ -33,22 +32,27 @@ const BEAUTIFY_SETTING = {
   space_before_conditional: true
 };
 
-// Inline replacement for legacy createSource (no longer imported).
-// Renders an EJS template with data, applies hook overrides, beautifies JS, and writes/appends to file.
 async function writeSource({ templatePath, templateData, setting }, { checkCreateSourcePass = false } = {}) {
   if (!templatePath || !templateData || !setting) {
     throw new Error('Invalid IntTest source item: missing templatePath/templateData/setting');
   }
 
-  const { savePath, hookPath, saveFileName, fileExtension, isAppend = false, initialData, generateHookFile = true } = setting;
+  const {
+    savePath,
+    hookPath,
+    saveFileName,
+    fileExtension,
+    isAppend = false,
+    initialData,
+    generateHookFile = true
+  } = setting;
 
   if (checkCreateSourcePass) {
-    // Validate phase: compile template to check for errors, no write
     try {
       ejs.compile(readFileSync(templatePath, 'utf8'))(templateData);
       return [true, {}];
-    } catch (err) {
-      return [false, err];
+    } catch (error) {
+      return [false, error];
     }
   }
 
@@ -63,26 +67,23 @@ async function writeSource({ templatePath, templateData, setting }, { checkCreat
 
   let dataToSave = ejs.compile(readFileSync(templatePath, 'utf8'))(templateData);
 
-  // Apply hook overrides (regex-based, matches legacy CreateSource.js behavior)
   if (existsSync(hookFilePath)) {
     const hookData = readFileSync(hookFilePath, 'utf8');
-    // anyDoubleTag: matches //(<tagName>)...//(</tagName>)  (JS) or #<#tagName#>...#<#/tagName#> (YML)
     const anyDoubleTag = isJs
-      ? new RegExp('\\/\\/\\\\(<(\\w+)>\\\\)([\\\\s\\\\S]*?)\\/\\/\\\\(<\\/\\\\1>\\\\)', 'gm')
+      ? new RegExp('\\/\\/\\(<(\\w+)>\\)([\\s\\S]*?)\\/\\/\\(<\\/\\1>\\)', 'gm')
       : isYml
-        ? new RegExp('\\#<#(\\w+)#>([\\\\s\\\\S]*?)\\#<#\\/\\1#>', 'gm')
+        ? new RegExp('\\#<#(\\w+)#>([\\s\\S]*?)\\#<#\\/\\1#>', 'gm')
         : null;
-    // doubleTag(name): extracts content between //(<name>) and //(</name>)  (or YML equivalent)
     const doubleTag = isJs
-      ? (name) => new RegExp(`\\/\\/\\\\(<${name}>\\\\)([\\\\s\\\\S]*?)\\/\\/\\\\(<\\/${name}>\\\\)`, 'gm')
+      ? (name) => new RegExp(`\\/\\/\\(<${name}>\\)([\\s\\S]*?)\\/\\/\\(<\\/${name}>\\)`, 'gm')
       : isYml
-        ? (name) => new RegExp(`\\#<#${name}#>([\\\\s\\\\S]*?)\\#<#\\/${name}#>`, 'gm')
+        ? (name) => new RegExp(`\\#<#${name}#>([\\s\\S]*?)\\#<#\\/${name}#>`, 'gm')
         : null;
 
     if (anyDoubleTag && doubleTag) {
-      dataToSave = dataToSave.replace(anyDoubleTag, (match, tagName) =>
+      dataToSave = dataToSave.replace(anyDoubleTag, (match, tagName) => (
         hookData.match(doubleTag(tagName)) ?? match
-      );
+      ));
     }
   }
 
@@ -90,76 +91,51 @@ async function writeSource({ templatePath, templateData, setting }, { checkCreat
 
   if (isAppend) {
     const shouldWriteWithInitial = !existsSync(filePath) && initialData;
-    const content = (shouldWriteWithInitial ? initialData : '') + dataToSave + '\n\n';
-    shouldWriteWithInitial
-      ? writeFileSync(filePath, content, 'utf8')
-      : appendFileSync(filePath, dataToSave + '\n\n', 'utf8');
-  } else {
-    writeFileSync(filePath, dataToSave, 'utf8');
+    const content = `${shouldWriteWithInitial ? initialData : ''}${dataToSave}\n\n`;
+
+    if (shouldWriteWithInitial) {
+      writeFileSync(filePath, content, 'utf8');
+    } else {
+      appendFileSync(filePath, `${dataToSave}\n\n`, 'utf8');
+    }
+    return [true, {}];
   }
-}
 
-// Inline replacement for legacy getLocalConfig('iz_serviceTag') — reads from rootPath instead of process.cwd().
-function getServiceTag(rootPath) {
-  const configPath = join(rootPath, 'config', 'serverless.config.yml');
-  const config = yaml.parse(readFileSync(configPath, 'utf8'));
-  return config?.main_config?.iz_serviceTag;
+  writeFileSync(filePath, dataToSave, 'utf8');
+  return [true, {}];
 }
 
-/**
- * Generate integration test files (events, tests, pathIntTest) for the service.
- * Result-Driven refactor: flat pipeline, no createSource/libs dependencies.
- *
- * @param {string} rootPath - Service root path containing /config and /app
- * @param {Object} [options]
- * @param {string} [options.outputPath] - Where to write (default: rootPath)
- * @param {string} [options.s3Prefix] - S3 prefix for IntTest config (optional)
- * @param {Object} [options._izContext] - Logger context (default: silent logger)
- * @returns {Promise<{ serviceTag: string, count: number, durationMs: number }>}
- */
 export async function generateIntTest(rootPath, options = {}) {
   const {
     outputPath = rootPath,
     s3Prefix = null,
-    _izContext = { logger: { debug: () => {}, info: console.info, warn: console.warn, error: console.error } }
+    _izContext = {
+      logger: {
+        debug: () => {},
+        info: console.info,
+        warn: console.warn,
+        error: console.error
+      }
+    }
   } = options;
 
   const startTime = Date.now();
   const serviceTag = getServiceTag(rootPath);
   if (!serviceTag) {
-    throw new Error('Missing iz_serviceTag in serverless.config.yml — required for IntTest generation');
+    throw new Error('Missing iz_serviceTag in serverless.config.yml — required IntTest generation');
   }
 
   const savePath = join(outputPath, 'src', 'generateIntegrationTest');
-
-  // Get IntTest data (events + tests + pathIntTest) from sub-orchestrator
   const items = await generateTestTemplate(_izContext, savePath, {
     serviceTag,
     rootPath,
     s3Prefix
   });
 
-  // Validate phase: compile each template to catch errors early
-  for (const item of items) {
-    if (!item || !item.templatePath || !item.templateData || !item.setting) {
-      throw new Error('Invalid IntTest source item: missing templatePath/templateData/setting');
-    }
-    const [status, errors] = await writeSource(item, { checkCreateSourcePass: true });
-    if (!status) {
-      throw new Error(`IntTest template validation failed: ${errors?.message || errors}`);
-    }
-  }
-
-  // Write phase: render + write each file (mirrors legacy two-pass pattern)
-  for (const item of items) {
-    if (item.setting?.savePath && existsSync(item.setting.savePath)) {
-      rmSync(item.setting.savePath, { recursive: true, force: true });
-    }
-    await writeSource(item, { checkCreateSourcePass: false });
-  }
-
-  // Note: legacy `uploadLib.uploadTos3(...)` was called here. S3 upload is intentionally
-  // skipped in this refactor — downstream services can upload manually if needed.
+  await runTemplateItems(items, {
+    writeSource,
+    errorPrefix: 'IntTest source'
+  });
 
   const durationMs = Date.now() - startTime;
   return { serviceTag, count: items.length, durationMs };

package/src/generateResourceIntTest.js

@@ -1,5 +1,4 @@
-/*
-Copyright (C) 2020 Sven Mason <http://izara.io>
+/* 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
@@ -8,33 +7,33 @@ 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
+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/>.
+along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
-import { readFileSync, writeFileSync, mkdirSync, existsSync, rmSync } from 'fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
 import { join } from 'path';
-import yaml from 'yaml';
 import ejs from 'ejs';
 
 import generateResourceTemplate from './generateResources/IntTest/generateResources/generateResources.js';
+import { getServiceTag, runTemplateItems } from './intTestGeneratorShared.js';
 
-// Minimal writeSource for resource generation (no hook support, no beautify — resources are .json)
 function writeSource({ templatePath, templateData, setting }, { checkCreateSourcePass = false } = {}) {
   if (!templatePath || !templateData || !setting) {
     throw new Error('Invalid IntTest resource item: missing templatePath/templateData/setting');
   }
+
   const { savePath, saveFileName, fileExtension } = setting;
 
   if (checkCreateSourcePass) {
     try {
       ejs.compile(readFileSync(templatePath, 'utf8'))(templateData);
       return [true, {}];
-    } catch (err) {
-      return [false, err];
+    } catch (error) {
+      return [false, error];
     }
   }
 
@@ -43,59 +42,35 @@ function writeSource({ templatePath, templateData, setting }, { checkCreateSourc
 
   const dataToSave = ejs.compile(readFileSync(templatePath, 'utf8'))(templateData);
   writeFileSync(filePath, dataToSave, 'utf8');
+  return [true, {}];
 }
 
-function getServiceTag(rootPath) {
-  const configPath = join(rootPath, 'config', 'serverless.config.yml');
-  const config = yaml.parse(readFileSync(configPath, 'utf8'));
-  return config?.main_config?.iz_serviceTag;
-}
-
-/**
- * Generate integration test shared resources (tableNames + function components) for the service.
- * Result-Driven refactor: flat pipeline, no createSource/libs dependencies.
- *
- * @param {string} rootPath - Service root path containing /config and /app
- * @param {Object} [options]
- * @param {string} [options.outputPath] - Where to write (default: rootPath)
- * @param {Object} [options._izContext] - Logger context (default: silent logger)
- * @returns {Promise<{ serviceTag: string, count: number, durationMs: number }>}
- */
 export async function generateResourceIntTest(rootPath, options = {}) {
   const {
     outputPath = rootPath,
-    _izContext = { logger: { debug: () => {}, info: console.info, warn: console.warn, error: console.error } }
+    _izContext = {
+      logger: {
+        debug: () => {},
+        info: console.info,
+        warn: console.warn,
+        error: console.error
+      }
+    }
   } = options;
 
   const startTime = Date.now();
   const serviceTag = getServiceTag(rootPath);
   if (!serviceTag) {
-    throw new Error('Missing iz_serviceTag in serverless.config.yml — required for IntTest resource generation');
+    throw new Error('Missing iz_serviceTag in serverless.config.yml — required IntTest resource generation');
   }
 
   const savePath = join(outputPath, 'src', 'generateIntegrationTest');
-
-  // Get IntTest resource data from sub-orchestrator
   const items = await generateResourceTemplate(_izContext, savePath, { serviceTag });
 
-  // Validate phase
-  for (const item of items) {
-    if (!item || !item.templatePath || !item.templateData || !item.setting) {
-      throw new Error('Invalid IntTest resource item: missing templatePath/templateData/setting');
-    }
-    const [status, errors] = writeSource(item, { checkCreateSourcePass: true });
-    if (!status) {
-      throw new Error(`IntTest resource template validation failed: ${errors?.message || errors}`);
-    }
-  }
-
-  // Write phase
-  for (const item of items) {
-    if (item.setting?.savePath && existsSync(item.setting.savePath)) {
-      rmSync(item.setting.savePath, { recursive: true, force: true });
-    }
-    writeSource(item, { checkCreateSourcePass: false });
-  }
+  await runTemplateItems(items, {
+    writeSource,
+    errorPrefix: 'IntTest resource'
+  });
 
   const durationMs = Date.now() - startTime;
   return { serviceTag, count: items.length, durationMs };