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

package/src/codeGenerators/resource/sls_yaml/FlowResourceYamlGenerator.js

@@ -2,7 +2,7 @@ import path from 'path';
 import fs from 'fs/promises';
 import { fileURLToPath } from 'url';
 import ejs from 'ejs';
-import { getFlowsForGeneration } from '../../app/src/generatedCode/Flow/_internal/shared/flowSelection.js';
+import { getFlowsForGeneration } from '../../app/src/generatedCode/Flow/_shared/shared/flowSelection.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -144,6 +144,34 @@ export async function generateFlowResourceYaml(allSchemas, options) {
         }
     }
 
+    // Add hardcoded ownTopic flows for CRUD, RBAC, Relationship
+    const systemOwnTopicFlows = [
+        'Create', 'Update', 'Delete', // CRUD
+        'CreateRelationship', 'UpdateRelationship', 'DeleteRelationship', 'ChangeRelationship', 'MoveRelationship', // Relationship
+        'CreateTargetRole', 'DeleteTargetRole', 'CreateRolePermissions', 'DeleteRolePermissions', 'CreateUserRole', 'DeleteUserFromRole' // RBAC
+    ];
+    for (const flowTag of systemOwnTopicFlows) {
+        const yamlContent = ejs.render(resourceYamlTpl, { queueName: flowTag });
+        await appendToFile(yamlOutputPath, yamlContent);
+        generatedCount++;
+        
+        // BeforeLogical queues for CRUD
+        if (['Create', 'Update', 'Delete'].includes(flowTag)) {
+            // Since we don't have beforeLogical configs here, we assume we might need them or we can just generate a generic one?
+            // For now, only custom flows generate beforeLogical dynamically above.
+        }
+    }
+
+    // Generate Dsq queues for Relationship
+    const relationshipActions = ['CreateRelationship', 'UpdateRelationship', 'DeleteRelationship', 'GetRelationship', 'ChangeRelationship', 'MoveRelationship'];
+    const resourceSqsYamlTplPath = path.join(__dirname, 'templates', 'crud', 'ResourceSqsYaml.ejs');
+    const resourceSqsYamlTpl = await fs.readFile(resourceSqsYamlTplPath, 'utf-8');
+    for (const action of relationshipActions) {
+        const yamlContent = ejs.render(resourceSqsYamlTpl, { queueName: action + 'Dsq' });
+        await appendToFile(yamlOutputPath, yamlContent);
+        generatedCount++;
+    }
+
     // Add System Queues
     const systemQueues = [
         'ProcessLogical',
@@ -157,11 +185,10 @@ export async function generateFlowResourceYaml(allSchemas, options) {
         'GetNodeComplete'
     ];
 
-    const resourceSqsYamlTplPath = path.join(__dirname, 'templates', 'crud', 'ResourceSqsYaml.ejs');
-    const resourceSqsYamlTpl = await fs.readFile(resourceSqsYamlTplPath, 'utf-8');
+    const resourceSqsYamlTplGlobal = await fs.readFile(resourceSqsYamlTplPath, 'utf-8');
 
     for (const sysQueue of systemQueues) {
-        const yamlContent = ejs.render(resourceSqsYamlTpl, {
+        const yamlContent = ejs.render(resourceSqsYamlTplGlobal, {
             queueName: sysQueue
         });
         await appendToFile(yamlOutputPath, yamlContent);

package/src/core/renderTemplateFile.js

@@ -0,0 +1,22 @@
+import fs from 'fs/promises';
+import path from 'path';
+import ejs from 'ejs';
+
+async function renderTemplateFile(templatePath, templateData = {}, { views } = {}) {
+  const template = await fs.readFile(templatePath, 'utf8');
+  return ejs.render(template, templateData, views ? { views } : undefined);
+}
+
+async function writeRenderedTemplate(templatePath, outputPath, templateData = {}, options = {}) {
+  const content = await renderTemplateFile(templatePath, templateData, options);
+  await fs.mkdir(path.dirname(outputPath), { recursive: true });
+  await fs.writeFile(outputPath, content, 'utf8');
+}
+
+async function appendRenderedTemplate(templatePath, outputPath, templateData = {}, options = {}) {
+  const content = await renderTemplateFile(templatePath, templateData, options);
+  await fs.mkdir(path.dirname(outputPath), { recursive: true });
+  await fs.appendFile(outputPath, `\n${content}`, 'utf8');
+}
+
+export { appendRenderedTemplate, renderTemplateFile, writeRenderedTemplate };

package/src/generateCode.js

@@ -5,17 +5,19 @@ 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/_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 { 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 { 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,6 +29,7 @@ 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';
 
@@ -40,36 +43,75 @@ export async function generateCode(rootPath, options) {
   const generatedCodePath = path.join(outputPath, 'app', 'src', 'generatedCode');
 
   // Backup existing hook files to prevent them from being wiped out
-  const hookBackups = [];
-  function backupHooks(currentDir) {
-    if (!fs.existsSync(currentDir)) return;
-    const items = fs.readdirSync(currentDir, { withFileTypes: true });
-
-    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));
-        }
-      }
-    }
-  }
-  
-  console.log('[INFO] [generateCode] STATUS=BACKUP | Backing up existing hook files...');
-  backupHooks(generatedCodePath);
-
-  console.log(
+ const hookBackups = [];
+ 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');
+ 
+   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...');
+ collectHookBackups(outputPath);
+
+console.log(
     '[INFO] [generateCode] STATUS=CLEANUP | Removing old generatedCode and resource directories...'
   );
   await fs.promises.rm(generatedCodePath, {
@@ -97,38 +139,21 @@ 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);
@@ -148,66 +173,74 @@ 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);
 
   // 3. Hook Integration
-  console.log(
-    '[INFO] [generateCode] STATUS=HOOKS | Processing hook folders beside source folders...'
-  );
-
-  function processSourceHooks(currentDir) {
-    if (!fs.existsSync(currentDir)) return;
-    const items = fs.readdirSync(currentDir, { withFileTypes: true });
-
-    const hasSource = items.some(
-      item => item.isDirectory() && item.name === 'source'
-    );
-    if (hasSource) {
-      const sourcePath = path.join(currentDir, 'source');
-      const hookPath = path.join(currentDir, 'hook');
-
-      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.`
-            );
-          }
-        }
-      }
-    }
-
-    for (const item of items) {
-      if (
-        item.isDirectory() &&
-        item.name !== 'source' &&
-        item.name !== 'hook'
-      ) {
-        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...`);
-    for (const backup of hookBackups) {
-      const hookDir = path.join(generatedCodePath, backup.relativePath);
-      if (!fs.existsSync(hookDir)) {
-        fs.mkdirSync(hookDir, { recursive: true });
-      }
-      fs.writeFileSync(path.join(hookDir, backup.name), backup.content);
-    }
-  }
-
-  processSourceHooks(generatorOptions.outputPath);
+ console.log(
+   '[INFO] [generateCode] STATUS=HOOKS | Processing hook folders beside source folders...'
+ );
+ 
+ function processSourceHooks(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');
+
+   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;
+ 
+       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') continue;
+     processSourceHooks(path.join(currentDir, item.name));
+   }
+ }
+ 
+ // Restore backed-up hooks
+ 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(outputPath, backup.relativePath);
+     fs.writeFileSync(path.join(hookDir, backup.name), backup.content);
+   }
+ }
+ 
+ processSourceHooks(generatorOptions.outputPath);
 
   console.log(
     '[INFO] [generateCode] STATUS=FINISHED | Code generation complete.'

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 };