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

package/src/generate.js

@@ -0,0 +1,130 @@
+/*
+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 { join } from 'path';
+import { validator } from '@izara_project/izara-core-library-service-schemas';
+import { basicValidatorSchema } from '@izara_project/izara-shared-service-schemas';
+import { generateCode } from './generateCode.js';
+import { generateSchema } from './generateSchema.js';
+
+const { validateLocalSchema } = validator;
+
+/**
+ * High-level code generation API.
+ * Consumer only needs to provide rootPath — everything else is auto-resolved.
+ *
+ * Wires legacy API surface (Logger + validateLocalSchema) onto the new
+ * Result-Driven flat-pipeline generators.
+ *
+ * @param {string} rootPath       - Root path containing /app and /config
+ * @param {Object} [options]
+ * @param {Object} [options.logger]          - Custom logger (default: silent)
+ * @param {string} [options.configPath]      - Override config path
+ * @param {boolean} [options.skipValidation] - Skip schema validation (default: false)
+ * @param {boolean} [options.skipGenerateSchema] - Skip auto-generating dynamic schemas (default: false)
+ * @param {string} [options.outputPath]      - Where to write generated code (default: rootPath)
+ * @returns {Promise<{ durationMs: number }>}
+ */
+async function generate(rootPath, options = {}) {
+  const {
+    logger = createSilentLogger(),
+    configPath = join(rootPath, 'config', 'serverless.config.yml'),
+    skipValidation = false,
+    skipGenerateSchema = false,
+    outputPath = rootPath
+  } = options;
+
+  const schemasPath = join(rootPath, 'app', 'src', 'schemas');
+
+  // Auto-generate dynamic schemas before validation (unless skipped)
+  if (!skipGenerateSchema) {
+    await generateSchema(rootPath, { outputPath });
+  }
+
+  // Validate schemas before generating (unless skipped)
+  if (!skipValidation) {
+    patchFlowStepsValidationSchema();
+
+    console.info('[INFO] [generate]     STATUS=VALIDATING| local schemas...');
+    const validateStartTime = Date.now();
+
+    const result = await validateLocalSchema(
+      { logger },
+      schemasPath,
+      configPath
+    );
+
+    const validateDuration = Date.now() - validateStartTime;
+    console.info(
+      `[INFO] [generate]     STATUS=VALIDATED | errors=${result.validateErrors.length} | elapsedMs=${validateDuration}`
+    );
+
+    if (result.validateErrors.length > 0) {
+      logger.error(
+        'Validation failed with following errors:',
+        result.validateErrors
+      );
+      const err = new Error('Schema validation failed');
+      err.validateErrors = result.validateErrors;
+      throw err;
+    }
+  }
+
+  const startTime = Date.now();
+  await generateCode(rootPath, { outputPath });
+  const durationMs = Date.now() - startTime;
+
+  return { durationMs };
+}
+
+function patchFlowStepsValidationSchema() {
+  const flowStepsSchema = basicValidatorSchema.basicFlowSchema?.properties?.flowSteps;
+
+  if (!flowStepsSchema || flowStepsSchema.oneOf) return;
+  const objectStepSchema = {
+    ...flowStepsSchema.items,
+    required: (flowStepsSchema.items.required || []).filter(item => item !== 'stepName')
+  };
+
+  basicValidatorSchema.basicFlowSchema.properties.flowSteps = {
+    oneOf: [
+      flowStepsSchema,
+      {
+        type: 'object',
+        minProperties: 1,
+        patternProperties: {
+          [basicValidatorSchema.strNotEmptyRegex]: objectStepSchema
+        }
+      }
+    ]
+  };
+}
+
+/**
+ * Creates a silent logger that only outputs errors.
+ * @returns {Object} Logger interface
+ */
+function createSilentLogger() {
+  return {
+    debug: () => {},
+    info: () => {},
+    warn: () => {},
+    error: () => {}
+  };
+}
+
+export { generate };

package/src/generateCode.js

@@ -1,52 +1,215 @@
-/*
-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 { fetchSchemas }     from './pipeline/fetchSchemas.js';
-import { transformSchemas } from './pipeline/transformSchemas.js';
-import { validateSources }  from './pipeline/validateSources.js';
-import { writeSources }     from './pipeline/writeSources.js';
-
-/**
- * Orchestrates code generation from flow schemas, object schemas, and external services.
- *
- * @param {Object} _izContext - Context object with logger
- * @param {string} rootServicePath - Root path of the service
- * @param {Object} settings - Optional generation settings
- * @returns {Promise<void>}
- */
-async function generateCodeWithTemplate(_izContext, rootServicePath, settings = {}) {
-  try {
-    const startTime = Date.now();
-    console.info(`[INFO] [generateCode] STATUS=START     | path=${rootServicePath}`);
-
-    const schemas = await fetchSchemas(_izContext, rootServicePath);
-    const sources = await transformSchemas(_izContext, rootServicePath, schemas, settings);
-    await validateSources(_izContext, rootServicePath, sources);
-    await writeSources(sources);
-
-    const totalDuration = Date.now() - startTime;
-    console.info(
-      `[INFO] [generateCode] STATUS=SUCCESS   | ${'files=' + sources.length} | totalMs=${totalDuration}`
+import fs from 'fs';
+import path from 'path';
+
+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 { 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 { 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';
+import { generateRoleNameConfig } from './codeGenerators/app/sls_yaml/RoleNameConfigGenerator.js';
+import { generateFunctionYaml } from './codeGenerators/app/sls_yaml/FunctionYamlGenerator.js';
+import { generateInitialSetup } from './codeGenerators/app/initial_setup/InitialSetupGenerator.js';
+import { generateCodeLibs } from './codeGenerators/app/src/generatedCode/libs/GenerateCodeLibsGenerator.js';
+import { generateConsts } from './codeGenerators/app/src/generatedCode/libs/ConstsGenerator.js';
+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 { 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) {
+  console.log(
+    '[INFO] [generateCode] STATUS=STARTING | Generating code files from all schemas...'
+  );
+
+  // Clean workspace
+  const outputPath = options.outputPath || rootPath;
+  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(
+    '[INFO] [generateCode] STATUS=CLEANUP | Removing old generatedCode and resource directories...'
+  );
+  await fs.promises.rm(generatedCodePath, {
+    recursive: true,
+    force: true
+  });
+  await fs.promises.rm(
+    path.join(outputPath, 'app', 'sls_yaml', 'generatedCode'),
+    { recursive: true, force: true }
+  );
+  await fs.promises.rm(path.join(outputPath, 'resource'), {
+    recursive: true,
+    force: true
+  });
+
+  policyRegistry.clear();
+
+  // 1. Parsing & Hydration Pipeline
+  console.log('[INFO] [generateCode] STATUS=PARSING | ObjectSchemas...');
+  const objectData = await parseObjectSchemas(rootPath);
+
+  console.log('[INFO] [generateCode] STATUS=PARSING | RelationshipSchemas...');
+  const relationshipData = await parseRelationshipSchemas(rootPath, objectData);
+
+  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 || [])
+    ]
+  };
+
+  // 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 generateFlowMainFunction(allSchemas, generatorOptions);
+  await generateFlowEntryPoint(allSchemas, generatorOptions);
+  await generateFlowSteps(allSchemas, generatorOptions);
+  await generateFlowOut(allSchemas, generatorOptions);
+  await generateFlowResourceYaml(allSchemas, generatorOptions);
+  await generateRbacFlows(allSchemas, generatorOptions);
+  await generateRelationshipFlows(allSchemas, generatorOptions);
+  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 generateDynamoDBTables(allSchemas, generatorOptions);
+  await generateFindData(allSchemas, generatorOptions);
+  await generateCodeLibs(generatorOptions);
+  await generateConsts(generatorOptions);
+  await generateProcessLogical(generatorOptions);
+  await generateRoleNameConfig(allSchemas, generatorOptions);
+  await generateProcessLogicalYaml(allSchemas, 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'
     );
-  } catch (error) {
-    console.error('[generateCode] error:', error);
-    _izContext.logger.error('[generateCode] error:', error);
-    throw error;
+    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));
+      }
+    }
   }
-}
 
-export default generateCodeWithTemplate;
+  // 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=FINISHED | Code generation complete.'
+  );
+}

package/src/generateIntTest.js

@@ -0,0 +1,166 @@
+/*
+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 { readFileSync, writeFileSync, appendFileSync, mkdirSync, existsSync, rmSync } 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';
+
+const BEAUTIFY_SETTING = {
+  indent_size: '2',
+  indent_char: ' ',
+  max_preserve_newlines: '0',
+  keep_array_indentation: true,
+  indent_scripts: 'separate',
+  brace_style: ['preserve-inline', 'none'],
+  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;
+
+  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];
+    }
+  }
+
+  const isJs = fileExtension === '.js';
+  const isYml = fileExtension === '.yml';
+  const hookDataPath = hookPath ?? join(savePath, '../hook/');
+  const filePath = `${savePath}${saveFileName}${fileExtension}`.trim();
+  const hookFilePath = `${hookDataPath}${saveFileName}${fileExtension}`.trim();
+
+  if (!existsSync(savePath)) mkdirSync(savePath, { recursive: true });
+  if (generateHookFile && !existsSync(hookDataPath)) mkdirSync(hookDataPath, { recursive: true });
+
+  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')
+      : isYml
+        ? 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')
+      : isYml
+        ? (name) => new RegExp(`\\#<#${name}#>([\\\\s\\\\S]*?)\\#<#\\/${name}#>`, 'gm')
+        : null;
+
+    if (anyDoubleTag && doubleTag) {
+      dataToSave = dataToSave.replace(anyDoubleTag, (match, tagName) =>
+        hookData.match(doubleTag(tagName)) ?? match
+      );
+    }
+  }
+
+  if (isJs) dataToSave = beautify(dataToSave, BEAUTIFY_SETTING);
+
+  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');
+  }
+}
+
+// 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;
+}
+
+/**
+ * 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 } }
+  } = 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');
+  }
+
+  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.
+
+  const durationMs = Date.now() - startTime;
+  return { serviceTag, count: items.length, durationMs };
+}

package/src/generateResourceIntTest.js

@@ -0,0 +1,102 @@
+/*
+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 { readFileSync, writeFileSync, mkdirSync, existsSync, rmSync } from 'fs';
+import { join } from 'path';
+import yaml from 'yaml';
+import ejs from 'ejs';
+
+import generateResourceTemplate from './generateResources/IntTest/generateResources/generateResources.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];
+    }
+  }
+
+  const filePath = `${savePath}${saveFileName}${fileExtension}`.trim();
+  if (!existsSync(savePath)) mkdirSync(savePath, { recursive: true });
+
+  const dataToSave = ejs.compile(readFileSync(templatePath, 'utf8'))(templateData);
+  writeFileSync(filePath, dataToSave, 'utf8');
+}
+
+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 } }
+  } = 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');
+  }
+
+  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 });
+  }
+
+  const durationMs = Date.now() - startTime;
+  return { serviceTag, count: items.length, durationMs };
+}