@izara_project/izara-core-generate-service-code 1.0.57 → 1.0.59

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izara_project/izara-core-generate-service-code",
-  "version": "1.0.57",
+  "version": "1.0.59",
   "description": "Code for locally generating per service files",
   "homepage": "https://bitbucket.org/izara-core-support-services/izara-core-support-services-generate-service-code#readme",
   "repository": {

package/src/__tests__/getIntTestConfig.test.js

@@ -0,0 +1,51 @@
+import { describe, it, expect, jest, beforeEach, afterEach } from '@jest/globals';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+import libs from '../generateResources/IntTest/libs/libs.js';
+import { getObjectSchema } from '@izara_project/izara-core-library-service-schemas';
+
+const { getIntTestConfig } = libs;
+
+describe('getIntTestConfig path resolution', () => {
+  let originalGetDataFromPath;
+  let passedArgs;
+
+  beforeEach(() => {
+    originalGetDataFromPath = getObjectSchema.getDataFromPath;
+    passedArgs = null;
+    getObjectSchema.getDataFromPath = async (_izContext, folderName, rootFolderPath, options) => {
+      passedArgs = { folderName, rootFolderPath, options };
+      return [];
+    };
+  });
+
+  afterEach(() => {
+    getObjectSchema.getDataFromPath = originalGetDataFromPath;
+  });
+
+  it('Case 1: should resolve correctly when rootPath includes generateIntegrationTest', async () => {
+    const rootPath = '/home/ironfist/Pong/Izara Project/Izara-Market-Product/izara-market-products-sell-offer-price-pong/app/src/generateIntegrationTest/';
+    await getIntTestConfig({ logger: console }, 'generateIntegrationTest/libs/', rootPath);
+    
+    expect(passedArgs).not.toBeNull();
+    expect(passedArgs.folderName).toBe('libs');
+    expect(passedArgs.rootFolderPath).toBe('/home/ironfist/Pong/Izara Project/Izara-Market-Product/izara-market-products-sell-offer-price-pong/app/src/generateIntegrationTest');
+  });
+
+  it('Case 2: should resolve correctly when rootPath is repo root with app/src/... structure', async () => {
+    const tmpDir = path.join(os.tmpdir(), 'get-int-test-config-scratch');
+    fs.mkdirSync(tmpDir, { recursive: true });
+    fs.mkdirSync(path.join(tmpDir, 'app', 'src', 'generateIntegrationTest', 'libs'), { recursive: true });
+
+    try {
+      await getIntTestConfig({ logger: console }, 'generateIntegrationTest/libs/', tmpDir);
+      
+      expect(passedArgs).not.toBeNull();
+      expect(passedArgs.folderName).toBe('libs');
+      expect(passedArgs.rootFolderPath).toBe(path.join(tmpDir, 'app', 'src', 'generateIntegrationTest'));
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+});

package/src/__tests__/intTestGeneratorShared.test.cjs

@@ -0,0 +1,169 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+let getIntTestOutputPath;
+let runTemplateItems;
+
+const tempDirs = [];
+
+beforeAll(async () => {
+  ({ getIntTestOutputPath, runTemplateItems } =
+    await import('../intTestGeneratorShared.js'));
+});
+
+afterEach(() => {
+  for (const dir of tempDirs.splice(0)) {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+describe('getIntTestOutputPath', () => {
+  it('uses app/src when app directory exists', () => {
+    const rootPath = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'int-test-output-app-')
+    );
+    tempDirs.push(rootPath);
+    fs.mkdirSync(path.join(rootPath, 'app'));
+
+    expect(getIntTestOutputPath(rootPath)).toBe(
+      path.join(rootPath, 'app', 'src', 'generateIntegrationTest')
+    );
+  });
+
+  it('falls back to src when app directory is missing', () => {
+    const rootPath = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'int-test-output-src-')
+    );
+    tempDirs.push(rootPath);
+
+    expect(getIntTestOutputPath(rootPath)).toBe(
+      path.join(rootPath, 'src', 'generateIntegrationTest')
+    );
+  });
+
+  it('detects app from project root even when output path is different', () => {
+    const projectRootPath = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'int-test-output-project-root-')
+    );
+    const outputPath = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'int-test-output-custom-')
+    );
+    tempDirs.push(projectRootPath, outputPath);
+    fs.mkdirSync(path.join(projectRootPath, 'app'));
+
+    expect(getIntTestOutputPath(outputPath, projectRootPath)).toBe(
+      path.join(outputPath, 'app', 'src', 'generateIntegrationTest')
+    );
+  });
+});
+
+describe('runTemplateItems', () => {
+  it('skips empty array items', async () => {
+    const writeSource = jest.fn();
+
+    await runTemplateItems([[]], {
+      writeSource,
+      errorPrefix: 'IntTest resource'
+    });
+
+    expect(writeSource).not.toHaveBeenCalled();
+  });
+
+  it('validates items before writing', async () => {
+    const writeSource = jest.fn()
+      .mockResolvedValueOnce([true, {}])
+      .mockResolvedValueOnce([true, {}]);
+
+    await runTemplateItems([
+      {
+        templatePath: '/tmp/template.ejs',
+        templateData: { ok: true },
+        setting: { savePath: '/tmp/out' }
+      }
+    ], {
+      writeSource,
+      errorPrefix: 'IntTest resource'
+    });
+
+    expect(writeSource).toHaveBeenNthCalledWith(1, expect.any(Object), {
+      checkCreateSourcePass: true
+    });
+    expect(writeSource).toHaveBeenNthCalledWith(2, expect.any(Object), {
+      checkCreateSourcePass: false
+    });
+  });
+
+  it('preserves configured files when clearing a save path', async () => {
+    const savePath = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'int-test-preserve-save-path-')
+    );
+    tempDirs.push(savePath);
+    fs.writeFileSync(path.join(savePath, 'saveConfig.js'), 'keep');
+    fs.writeFileSync(path.join(savePath, 'old.js'), 'remove');
+    fs.mkdirSync(path.join(savePath, 'nested'));
+    fs.writeFileSync(path.join(savePath, 'nested', 'stale.json'), '{}');
+
+    const writeSource = jest.fn()
+      .mockResolvedValueOnce([true, {}])
+      .mockImplementationOnce(async ({ setting }) => {
+        fs.writeFileSync(path.join(setting.savePath, 'IntTestPath.js'), 'new');
+        return [true, {}];
+      });
+
+    await runTemplateItems([
+      {
+        templatePath: '/tmp/template.ejs',
+        templateData: { ok: true },
+        setting: {
+          savePath,
+          preserveFileNames: ['saveConfig.js']
+        }
+      }
+    ], {
+      writeSource,
+      errorPrefix: 'IntTest resource'
+    });
+
+    expect(fs.existsSync(path.join(savePath, 'saveConfig.js'))).toBe(true);
+    expect(fs.readFileSync(path.join(savePath, 'saveConfig.js'), 'utf8')).toBe('keep');
+    expect(fs.existsSync(path.join(savePath, 'old.js'))).toBe(false);
+    expect(fs.existsSync(path.join(savePath, 'nested'))).toBe(false);
+    expect(fs.existsSync(path.join(savePath, 'IntTestPath.js'))).toBe(true);
+  });
+
+  it('does not clear save path when cleanSavePath is false', async () => {
+    const savePath = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'int-test-no-clean-save-path-')
+    );
+    tempDirs.push(savePath);
+    fs.writeFileSync(path.join(savePath, 'config.json'), 'keep');
+    fs.mkdirSync(path.join(savePath, 'nested-dir'));
+    fs.writeFileSync(path.join(savePath, 'nested-dir', 'file.json'), '{}');
+
+    const writeSource = jest.fn()
+      .mockResolvedValueOnce([true, {}])
+      .mockImplementationOnce(async ({ setting }) => {
+        fs.writeFileSync(path.join(setting.savePath, 'IntTestPath.js'), 'new');
+        return [true, {}];
+      });
+
+    await runTemplateItems([
+      {
+        templatePath: '/tmp/template.ejs',
+        templateData: { ok: true },
+        setting: {
+          savePath,
+          cleanSavePath: false
+        }
+      }
+    ], {
+      writeSource,
+      errorPrefix: 'IntTest resource'
+    });
+
+    expect(fs.existsSync(path.join(savePath, 'config.json'))).toBe(true);
+    expect(fs.existsSync(path.join(savePath, 'nested-dir'))).toBe(true);
+    expect(fs.existsSync(path.join(savePath, 'IntTestPath.js'))).toBe(true);
+  });
+});

package/src/__tests__/pathIntTest.test.js

@@ -0,0 +1,103 @@
+import { describe, it, expect } from '@jest/globals';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+import generatePathIntTest from '../generateResources/IntTest/generateTests/pathIntTest/pathIntTest.js';
+
+describe('generatePathIntTest', () => {
+  it('creates IntTestPath data from generated files in the new folder structure', async () => {
+    const rootPath = fs.mkdtempSync(path.join(os.tmpdir(), 'int-test-path-'));
+    const srcPath = path.join(rootPath, 'app', 'src', 'generateIntegrationTest');
+    const serviceTag = 'svc-demo';
+
+    fs.mkdirSync(path.join(srcPath, serviceTag, 'orderCreate', 'caseA'), { recursive: true });
+    fs.mkdirSync(path.join(srcPath, serviceTag, 'orderCreate', 'orderCreate'), { recursive: true });
+    fs.mkdirSync(path.join(srcPath, serviceTag, 'shared'), { recursive: true });
+
+    fs.writeFileSync(path.join(srcPath, serviceTag, 'orderCreate', 'caseA', 'events.json'), '{}');
+    fs.writeFileSync(path.join(srcPath, serviceTag, 'orderCreate', 'orderCreate', 'tests.json'), '{}');
+    fs.writeFileSync(path.join(srcPath, serviceTag, 'shared', 'resources.json'), '{}');
+    fs.writeFileSync(path.join(srcPath, serviceTag, 'ignore.txt'), 'ignore');
+
+    try {
+      const result = await generatePathIntTest({}, srcPath, {
+        serviceTag,
+        s3Prefix: 'demo-prefix'
+      });
+
+      expect(result).toEqual({
+        templateData: {
+          intTestPaths: [
+            'test_config/demo-prefix/svc-demo/orderCreate/caseA/',
+            'test_config/demo-prefix/svc-demo/orderCreate/orderCreate/',
+            'test_config/demo-prefix/svc-demo/shared/'
+          ]
+        },
+        templatePath: expect.stringContaining('template.ejs'),
+        setting: {
+          generateHookFile: false,
+          savePath: path.join(srcPath, './libs/'),
+          saveFileName: 'IntTestPath',
+          fileExtension: '.js',
+          isAppend: false,
+          cleanSavePath: false
+        }
+      });
+    } finally {
+      fs.rmSync(rootPath, { recursive: true, force: true });
+    }
+  });
+
+  it('preserves test case folder name prefix even if it contains the serviceTag', async () => {
+    const rootPath = fs.mkdtempSync(path.join(os.tmpdir(), 'int-test-path-nested-'));
+    const srcPath = path.join(rootPath, 'app', 'src', 'generateIntegrationTest');
+    const serviceTag = 'SellOfferManager';
+
+    // Mock folder structure similar to the issue reported
+    const nestedTestFolder = path.join(srcPath, serviceTag, 'IntegrationTest_SellOfferManager_ProcessCalCombinedPricingHdrSqs__case_BasicCase');
+    fs.mkdirSync(nestedTestFolder, { recursive: true });
+    fs.writeFileSync(path.join(nestedTestFolder, 'events.json'), '{}');
+
+    try {
+      const result = await generatePathIntTest({}, srcPath, {
+        serviceTag,
+        s3Prefix: 'PongDev'
+      });
+
+      expect(result).toEqual({
+        templateData: {
+          intTestPaths: [
+            'test_config/PongDev/SellOfferManager/IntegrationTest_SellOfferManager_ProcessCalCombinedPricingHdrSqs__case_BasicCase/'
+          ]
+        },
+        templatePath: expect.stringContaining('template.ejs'),
+        setting: {
+          generateHookFile: false,
+          savePath: path.join(srcPath, './libs/'),
+          saveFileName: 'IntTestPath',
+          fileExtension: '.js',
+          isAppend: false,
+          cleanSavePath: false
+        }
+      });
+    } finally {
+      fs.rmSync(rootPath, { recursive: true, force: true });
+    }
+  });
+
+  it('returns empty when no generated files exist for the service tag', async () => {
+    const rootPath = fs.mkdtempSync(path.join(os.tmpdir(), 'int-test-path-empty-'));
+    const srcPath = path.join(rootPath, 'src', 'generateIntegrationTest');
+    fs.mkdirSync(srcPath, { recursive: true });
+
+    try {
+      await expect(generatePathIntTest({}, srcPath, {
+        serviceTag: 'missing-service',
+        s3Prefix: 'demo-prefix'
+      })).resolves.toEqual([]);
+    } finally {
+      fs.rmSync(rootPath, { recursive: true, force: true });
+    }
+  });
+});

package/src/codeGenerators/app/src/generatedCode/Flow/FlowSchemas/WebSocketGenerator.js

@@ -103,9 +103,13 @@ export async function generateWebSocket(allLocalFlowSchemas, appPath, outputBase
     // 4. SQS and SNS Subscriptions
     await renderAndAppend('ProcessWebSocket_Yaml.ejs', path.join(resourceYamlDir, 'generated-sns-in-sqs.yml'), processData);
 
+    const processedTopics = new Set();
     for (const flowSchema of allLocalFlowSchemas) {
         if (flowSchema.outputTopic) {
             const topicOut = upperCase(flowSchema.flowTag);
+            if (processedTopics.has(topicOut)) continue;
+            processedTopics.add(topicOut);
+
             await renderAndAppend('ProcessWebSocketSub_Yaml.ejs', path.join(resourceYamlDir, 'generated-sns-in-sqs.yml'), {
                 subscribeTo: topicOut,
                 queueName: queueName,

package/src/codeGenerators/app/src/generatedCode/SystemFlowSchemas/RegisterGenerator.js

@@ -126,14 +126,19 @@ export async function generateRegisterFlow(allLocalFlowSchemas, _appPath, output
     completeData
   );
 
+  const processedTopics = new Set();
   for (const flowSchema of allLocalFlowSchemas) {
     if (!flowSchema.outputTopic) continue;
 
+    const topicOut = upperCase(flowSchema.flowTag);
+    if (processedTopics.has(topicOut)) continue;
+    processedTopics.add(topicOut);
+
     await appendRenderedTemplate(
       path.join(wsTemplatesDir, 'ProcessWebSocketSub_Yaml.ejs'),
       resourceYamlPath,
       {
-        subscribeTo: upperCase(flowSchema.flowTag),
+        subscribeTo: topicOut,
         queueName: completeFunctionName,
         upperQueueName: upperCase(completeFunctionName)
       }

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

@@ -127,6 +127,7 @@ export async function generateFlowResourceYaml(allSchemas, options) {
 
   const systemOwnTopicFlows = [
     'ProcessLogical',
+    'PaginateProcessLogical',
     'FindData',
     'Create',
     'Update',
@@ -169,7 +170,6 @@ export async function generateFlowResourceYaml(allSchemas, options) {
   const systemQueues = [
     'Register',
     'WebSocket',
-    'PaginateProcessLogical',
     'CreateComplete',
     'UpdateComplete',
     'DeleteComplete',

package/src/generate.js

@@ -2,17 +2,17 @@
 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.
+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
+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 { join } from 'path';
@@ -24,53 +24,51 @@ import { generateSchema } from './generateSchema.js';
 const { validateLocalSchema } = validator;
 
 /**
- * High-level code generation API.
- * Consumer only needs to provide rootPath — everything else is auto-resolved.
+ * High-level API to validate schemas and generate code.
+ * Wires legacy Logger and validateLocalSchema.
  *
- * 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 }>}
+ * @param {string} rootPath - The root path of the project.
+ * @param {object} [options={}] - Configuration options.
+ * @param {object} [options.logger] - Logger instance.
+ * @param {string} [options.configPath] - Path to the serverless configuration file.
+ * @param {string} [options.outputPath] - Output directory path.
+ * @param {boolean} [options.skipValidation=false] - Whether to skip schema validation.
+ * @param {boolean} [options.skipGenerateSchema=false] - Whether to skip schema generation.
+ * @param {boolean} [options.skipGenerateCode=false] - Whether to skip code generation.
+ * @param {Array} [options.schemaTemplateConfig] - Schema template configuration.
+ * @returns {Promise<{durationMs: number}>} Generation duration details.
  */
 async function generate(rootPath, options = {}) {
   const {
     logger = createSilentLogger(),
     configPath = join(rootPath, 'config', 'serverless.config.yml'),
+    outputPath = rootPath,
     skipValidation = false,
     skipGenerateSchema = false,
-    outputPath = rootPath
+    skipGenerateCode = false,
+    schemaTemplateConfig
   } = options;
 
   const schemasPath = join(rootPath, 'app', 'src', 'schemas');
 
-  // Auto-generate dynamic schemas before validation (unless skipped)
   if (!skipGenerateSchema) {
-    await generateSchema(rootPath, { outputPath, configPath });
+    await generateSchema(rootPath, {
+      configPath,
+      outputPath,
+      schemaTemplateConfig
+    });
   }
 
-  // Validate schemas before generating (unless skipped)
   if (!skipValidation) {
     patchFlowStepsValidationSchema();
 
-    console.info('[INFO] [generate]     STATUS=VALIDATING| local schemas...');
+    console.info('[INFO] [generate] STATUS=VALIDATING | local schemas...');
     const validateStartTime = Date.now();
-
-    const result = await validateLocalSchema(
-      { logger },
-      schemasPath,
-      configPath
-    );
-
+    const result = await validateLocalSchema({ logger }, schemasPath, configPath);
     const validateDuration = Date.now() - validateStartTime;
+
     console.info(
-      `[INFO] [generate]     STATUS=VALIDATED | errors=${result.validateErrors.length} | elapsedMs=${validateDuration}`
+      `[INFO] [generate] STATUS=VALIDATED | errors=${result.validateErrors.length} | elapsedMs=${validateDuration}`
     );
 
     if (result.validateErrors.length > 0) {
@@ -84,20 +82,26 @@ async function generate(rootPath, options = {}) {
     }
   }
 
+  if (skipGenerateCode) {
+    return { durationMs: 0 };
+  }
+
   const startTime = Date.now();
   await generateCode(rootPath, { outputPath });
-  const durationMs = Date.now() - startTime;
-
-  return { durationMs };
+  return { durationMs: Date.now() - startTime };
 }
 
 function patchFlowStepsValidationSchema() {
   const flowStepsSchema = basicValidatorSchema.basicFlowSchema?.properties?.flowSteps;
+  if (!flowStepsSchema || flowStepsSchema.oneOf) {
+    return;
+  }
 
-  if (!flowStepsSchema || flowStepsSchema.oneOf) return;
   const objectStepSchema = {
     ...flowStepsSchema.items,
-    required: (flowStepsSchema.items.required || []).filter(item => item !== 'stepName')
+    required: (flowStepsSchema.items.required || []).filter(
+      item => item !== 'stepName'
+    )
   };
 
   basicValidatorSchema.basicFlowSchema.properties.flowSteps = {
@@ -114,10 +118,6 @@ function patchFlowStepsValidationSchema() {
   };
 }
 
-/**
- * Creates a silent logger that only outputs errors.
- * @returns {Object} Logger interface
- */
 function createSilentLogger() {
   return {
     debug: () => {},

package/src/generateCode.js

@@ -37,6 +37,14 @@ function createGeneratorOptions(rootPath, options = {}) {
   };
 }
 
+/**
+ * Low-level generator to generate application code files from all schemas.
+ *
+ * @param {string} rootPath - The root path of the project.
+ * @param {object} [options={}] - Configuration options.
+ * @param {string} [options.outputPath] - Output directory path.
+ * @returns {Promise<void>}
+ */
 export async function generateCode(rootPath, options = {}) {
   console.log(
     '[INFO] [generateCode] STATUS=STARTING | Generating code files from all schemas...'
@@ -130,6 +138,57 @@ export async function generateCode(rootPath, options = {}) {
   );
   collectHookBackups(outputPath);
 
+  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));
+    }
+  }
+
   // ponytail: ensure hooks are restored even if generation fails
   try {
     console.log(
@@ -204,80 +263,30 @@ export async function generateCode(rootPath, options = {}) {
   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'
-    );
-    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.`
-        );
+  } finally {
+    // 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);
       }
-    } 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));
-    }
-  }
+    console.log(
+      '[INFO] [generateCode] STATUS=HOOKS | Processing hook folders beside source folders...'
+    );
+    processSourceHooks(generatorOptions.outputPath);
 
-  } finally {
-    // Restore backed-up hooks
-    if (hookDirs.size > 0 || hookBackups.length > 0) {
     console.log(
-      `[INFO] [generateCode] STATUS=RESTORE | Restoring ${hookBackups.length} hook files...`
+      '[INFO] [generateCode] STATUS=FINISHED | Code generation complete.'
     );
-    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

@@ -20,7 +20,8 @@ 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';
+import { DEFAULT_BUCKET, uploadToS3 } from './generateResources/IntTest/upload/uploadIntTest.js';
+import { getIntTestOutputPath, getServiceTag, runTemplateItems } from './intTestGeneratorShared.js';
 
 const BEAUTIFY_SETTING = {
   indent_size: '2',
@@ -105,10 +106,26 @@ async function writeSource({ templatePath, templateData, setting }, { checkCreat
   return [true, {}];
 }
 
+/**
+ * Result-Driven generator to generate Integration Tests.
+ * Generates local files and can upload generated JSON payloads to S3.
+ *
+ * @param {string} rootPath - The root path of the project.
+ * @param {object} [options={}] - Configuration options.
+ * @param {string} [options.outputPath] - Output directory path.
+ * @param {string|null} [options.s3Prefix=null] - S3 key prefix for integration test resources.
+ * @param {boolean} [options.uploadToS3=false] - Upload generated IntTest JSON files to S3.
+ * @param {string} [options.s3Bucket='integrationtest-config-us-east-2'] - Target S3 bucket.
+ * @param {object} [options._izContext] - Integration context containing logger interface.
+ * @returns {Promise<{serviceTag: string, count: number, durationMs: number, uploadedCount: number, s3Bucket: string|null}>}
+ */
 export async function generateIntTest(rootPath, options = {}) {
   const {
     outputPath = rootPath,
     s3Prefix = null,
+    // ponytail: default uploadToS3 to false because generate-Resources uploads the files.
+    uploadToS3: shouldUploadToS3 = false,
+    s3Bucket = DEFAULT_BUCKET,
     _izContext = {
       logger: {
         debug: () => {},
@@ -125,7 +142,7 @@ export async function generateIntTest(rootPath, options = {}) {
     throw new Error('Missing iz_serviceTag in serverless.config.yml — required IntTest generation');
   }
 
-  const savePath = join(outputPath, 'src', 'generateIntegrationTest');
+  const savePath = getIntTestOutputPath(outputPath, rootPath);
   const items = await generateTestTemplate(_izContext, savePath, {
     serviceTag,
     rootPath,
@@ -137,6 +154,21 @@ export async function generateIntTest(rootPath, options = {}) {
     errorPrefix: 'IntTest source'
   });
 
+  let uploadedKeys = [];
+  if (shouldUploadToS3) {
+    uploadedKeys = await uploadToS3(join(savePath, serviceTag), {
+      serviceTag,
+      s3Prefix,
+      bucket: s3Bucket
+    });
+  }
+
   const durationMs = Date.now() - startTime;
-  return { serviceTag, count: items.length, durationMs };
+  return {
+    serviceTag,
+    count: items.length,
+    durationMs,
+    uploadedCount: uploadedKeys.length,
+    s3Bucket: shouldUploadToS3 ? s3Bucket : null
+  };
 }

package/src/generateResourceIntTest.js

@@ -1,9 +1,9 @@
 /* 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.
+it under the terms of the GNU Affero General Public License as published by
+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
@@ -19,7 +19,8 @@ import { join } from 'path';
 import ejs from 'ejs';
 
 import generateResourceTemplate from './generateResources/IntTest/generateResources/generateResources.js';
-import { getServiceTag, runTemplateItems } from './intTestGeneratorShared.js';
+import { DEFAULT_BUCKET, uploadToS3 } from './generateResources/IntTest/upload/uploadIntTest.js';
+import { getIntTestOutputPath, getServiceTag, runTemplateItems } from './intTestGeneratorShared.js';
 
 function writeSource({ templatePath, templateData, setting }, { checkCreateSourcePass = false } = {}) {
   if (!templatePath || !templateData || !setting) {
@@ -45,9 +46,25 @@ function writeSource({ templatePath, templateData, setting }, { checkCreateSourc
   return [true, {}];
 }
 
+/**
+ * Result-Driven generator to generate Integration Test resources.
+ * Generates local files and can upload generated resource payloads to S3.
+ *
+ * @param {string} rootPath - The root path of the project.
+ * @param {object} [options={}] - Configuration options.
+ * @param {string} [options.outputPath] - Output directory path.
+ * @param {string|null} [options.s3Prefix=null] - S3 key prefix for integration test resources.
+ * @param {boolean} [options.uploadToS3=Boolean(options.s3Prefix)] - Upload generated IntTest resource JSON files to S3.
+ * @param {string} [options.s3Bucket='integrationtest-config-us-east-2'] - Target S3 bucket.
+ * @param {object} [options._izContext] - Integration context containing logger interface.
+ * @returns {Promise<{serviceTag: string, count: number, durationMs: number, uploadedCount: number, s3Bucket: string|null}>}
+ */
 export async function generateResourceIntTest(rootPath, options = {}) {
   const {
     outputPath = rootPath,
+    s3Prefix = null,
+    uploadToS3: shouldUploadToS3 = Boolean(s3Prefix),
+    s3Bucket = DEFAULT_BUCKET,
     _izContext = {
       logger: {
         debug: () => {},
@@ -64,7 +81,7 @@ export async function generateResourceIntTest(rootPath, options = {}) {
     throw new Error('Missing iz_serviceTag in serverless.config.yml — required IntTest resource generation');
   }
 
-  const savePath = join(outputPath, 'src', 'generateIntegrationTest');
+  const savePath = getIntTestOutputPath(outputPath, rootPath);
   const items = await generateResourceTemplate(_izContext, savePath, { serviceTag });
 
   await runTemplateItems(items, {
@@ -72,6 +89,21 @@ export async function generateResourceIntTest(rootPath, options = {}) {
     errorPrefix: 'IntTest resource'
   });
 
+  let uploadedKeys = [];
+  if (shouldUploadToS3) {
+    uploadedKeys = await uploadToS3(join(savePath, serviceTag), {
+      serviceTag,
+      s3Prefix,
+      bucket: s3Bucket
+    });
+  }
+
   const durationMs = Date.now() - startTime;
-  return { serviceTag, count: items.length, durationMs };
+  return {
+    serviceTag,
+    count: items.length,
+    durationMs,
+    uploadedCount: uploadedKeys.length,
+    s3Bucket: shouldUploadToS3 ? s3Bucket : null
+  };
 }

package/src/generateResources/IntTest/generateTests/generateTemplate.js

@@ -44,16 +44,30 @@ async function generateCodeWithTemplate(_izContext, savePath, settings) {
     let allIntTestConfig = await getIntTestConfig(
       _izContext,
       'generateIntegrationTest/libs/',
-      rootPath
+      rootPath || savePath
+    );
+    const event = await generateEvent(
+      _izContext,
+      allIntTestConfig,
+      savePath,
+      serviceTag
+    );
+    const test = await generateTest(
+      _izContext,
+      allIntTestConfig,
+      savePath,
+      serviceTag
     );
-    const event = await generateEvent(_izContext, allIntTestConfig, savePath, serviceTag);
-    const test = await generateTest(_izContext, allIntTestConfig, savePath, serviceTag);
     const intTestBucketPath = await generatePathIntTest(_izContext, savePath, {
       serviceTag,
       s3Prefix
     });
 
-    allCreateSource.push(...event, ...test, intTestBucketPath);
+    allCreateSource.push(
+      ...[event, test, intTestBucketPath]
+        .flat()
+        .filter(item => !(Array.isArray(item) && item.length === 0))
+    );
 
     return allCreateSource;
   } catch (error) {

package/src/generateResources/IntTest/generateTests/pathIntTest/pathIntTest.js

@@ -1,65 +1,53 @@
-/*
-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
+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
+MERCHANTABILITY or FITNESS FOR 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 path, { join } from 'path';
+import path from 'path';
 import { fileURLToPath } from 'url';
+
+import { bucketPathForUpload } from '../../upload/uploadIntTest.js';
+
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const templatePath = path.join(__dirname, './template.ejs');
-
-// Refactored: legacy `bucketPathForUpload` (S3-based) was removed with IntTest/upload/.
-// The new flow doesn't sync IntTest configs to S3 — return empty array as no-op.
-async function bucketPathForUpload(_srcPath, _settings) {
-  return [];
-}
+const INT_TEST_SUFFIX_PATTERN = /(events|tests|resources|dynamoDBSeedDataTags|graphSeedDataTags)\.json$/;
 
 async function data(_izContext, srcPath, settings) {
-  // console.log('settingsInData', settings);
-  let intTestPaths = [];
-
-  let pathIntTestInBuckets = await bucketPathForUpload(
-    join(srcPath, `../../src/generateIntegrationTest/${settings.serviceTag}`),
+  const pathIntTestInBuckets = await bucketPathForUpload(
+    path.join(srcPath, settings.serviceTag),
     settings
   );
-  // console.log({ pathIntTestInBuckets });
-  if (!pathIntTestInBuckets || pathIntTestInBuckets.length === 0) {
-    return []
-  }
+  const intTestPaths = pathIntTestInBuckets
+    .filter(({ key }) => INT_TEST_SUFFIX_PATTERN.test(key))
+    .map(({ key }) => key.replace(INT_TEST_SUFFIX_PATTERN, ''));
 
-  for (const pathIntTestInBucket of pathIntTestInBuckets) {
-    if (pathIntTestInBucket.key.endsWith(".json")) {
-      let path = pathIntTestInBucket.key.replace(/(events|tests|resources|dynamoDBSeedDataTags|graphSeedDataTags).json$/,);
-      intTestPaths.push(`${path}`);
-    }
+  if (!intTestPaths.length) {
+    return [];
   }
 
   return {
     templateData: { intTestPaths },
-    templatePath: templatePath,
+    templatePath,
     setting: {
       generateHookFile: false,
-      savePath: path.join(srcPath, `./libs/`),
+      savePath: path.join(srcPath, './libs/'),
       saveFileName: 'IntTestPath',
       fileExtension: '.js',
-      fileExtension: '.js',
-      isAppend: false
+      isAppend: false,
+      cleanSavePath: false
     }
   };
 }
 
-
 export default data;

package/src/generateResources/IntTest/libs/libs.js

@@ -393,10 +393,18 @@ function createResourceName(eventTag) {
 }
 
 async function getIntTestConfig(_izContext, intTestPath, rootPath) {
+  // ponytail: find first existing integration test libs folder or fall back to standard path
+  const targetLibsPath = rootPath.includes('generateIntegrationTest')
+    ? path.join(rootPath.split('generateIntegrationTest')[0], 'generateIntegrationTest', 'libs')
+    : [
+        path.join(rootPath, 'app/src/generateIntegrationTest/libs'),
+        path.join(rootPath, 'src/generateIntegrationTest/libs')
+      ].find(fs.existsSync) || path.join(rootPath, 'src/generateIntegrationTest/libs');
+
   return await getObjectSchema.getDataFromPath(
     _izContext,
-    intTestPath,                 // :white_check_mark: ใช้ relative
-    path.join(rootPath, 'src/'), // :white_check_mark: root ที่ถูก (refactor: ใช้ rootPath แทน process.cwd())
+    path.basename(targetLibsPath),
+    path.dirname(targetLibsPath),
     { exceptFileName: 'saveConfig' }
   );
 }

package/src/generateResources/IntTest/upload/uploadIntTest.js

@@ -0,0 +1,82 @@
+/* Copyright (C) 2020 Sven Mason <http://izara.io>
+
+This program is free software: you can redistribute it and/or modify
+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 fs from 'fs';
+import path from 'path';
+
+import { s3 } from '@izara_project/izara-core-library-s3';
+import Logger from '@izara_project/izara-core-library-logger';
+
+const DEFAULT_BUCKET = 'integrationtest-config-us-east-2';
+const _izContext = { Logger };
+
+function getAllFiles(dirPath, filePaths = []) {
+  if (!fs.existsSync(dirPath)) return filePaths;
+
+  for (const file of fs.readdirSync(dirPath)) {
+    const fullPath = path.join(dirPath, file);
+    const stat = fs.statSync(fullPath);
+
+    if (stat.isDirectory()) {
+      getAllFiles(fullPath, filePaths);
+      continue;
+    }
+
+    filePaths.push(fullPath);
+  }
+
+  return filePaths;
+}
+
+async function bucketPathForUpload(folderPath, settings = {}) {
+  const dataToUploads = [];
+  const files = getAllFiles(folderPath);
+
+  for (const filePath of files) {
+    const fileContent = fs.readFileSync(filePath);
+    // ponytail: use indexOf to find first occurrence of serviceTag so nested test case folders containing the serviceTag name do not get cut off.
+    const index = settings.serviceTag ? filePath.indexOf(settings.serviceTag) : -1;
+    const relativePath = index !== -1
+      ? filePath.substring(index)
+      : path.basename(filePath);
+    const s3Key = path
+      .join('test_config', settings.s3Prefix || '', relativePath)
+      .split(path.sep)
+      .join('/');
+
+    dataToUploads.push({ key: s3Key, fileContent });
+  }
+
+  return dataToUploads;
+}
+
+async function uploadToS3(folderPath, settings = {}) {
+  const uploads = await bucketPathForUpload(folderPath, settings);
+  const bucket = settings.bucket || DEFAULT_BUCKET;
+
+  await Promise.all(uploads.map(({ key, fileContent }) => (
+    s3.putObjectS3(_izContext, {
+      Bucket: bucket,
+      Key: key,
+      Body: fileContent,
+      ContentType: 'application/json'
+    })
+  )));
+
+  return uploads.map(({ key }) => key);
+}
+
+export { DEFAULT_BUCKET, bucketPathForUpload, uploadToS3 };
+export default { DEFAULT_BUCKET, bucketPathForUpload, uploadToS3 };

package/src/generateSchema.js

@@ -15,34 +15,36 @@ import { generatePropertyValueRelationshipSchemas } from './schemaGenerators/app
 import { generateAttributeTreeObjectSchemas } from './schemaGenerators/app/src/schemas/ObjectSchemas/AttributeTreeSchemaGenerator.js';
 import { generateAttributeTreeRelationshipSchemas } from './schemaGenerators/app/src/schemas/RelationshipSchemas/AttributeTreeRelationshipSchemaGenerator.js';
 
-export async function generateSchema(rootPath, options) {
+/**
+ * Low-level generator to generate dynamic schemas (FlowSchema, etc.).
+ *
+ * @param {string} rootPath - The root path of the project.
+ * @param {object} [options={}] - Configuration options.
+ * @param {string} [options.configPath] - Path to the serverless configuration file.
+ * @param {string} [options.outputPath] - Output directory path.
+ * @param {Array} [options.schemaTemplateConfig] - Schema template configuration.
+ * @returns {Promise<void>}
+ */
+export async function generateSchema(rootPath, options = {}) {
   console.log(
     '[INFO] [generateSchema] STATUS=STARTING | Generating dynamic schemas (FlowSchema, etc.)...'
   );
 
-  // Parse service config to get serviceTag
-  const configPath = options?.configPath || path.join(rootPath, 'config', 'serverless.config.yml');
-  let serviceTag = 'unknownService';
-  try {
-    const serviceConfigStr = fs.readFileSync(configPath, 'utf8');
-    const serviceConfig = yaml.parse(serviceConfigStr);
-    serviceTag = serviceConfig?.main_config?.iz_serviceTag || 'unknownService';
-  } catch (e) {
-    console.warn(
-      `[WARNING] Could not read service config at ${configPath}. Using default serviceTag.`
-    );
-  }
+  const configPath =
+    options.configPath || path.join(rootPath, 'config', 'serverless.config.yml');
+  const serviceTag = readServiceTag(configPath);
 
-  // Phase 1 parsing just to get the raw data needed for generation
   const objectData = await parseObjectSchemas(rootPath);
+  applySchemaTemplateConfig(objectData, options.schemaTemplateConfig, serviceTag);
+
   const flowData = await parseFlowSchemas(rootPath, objectData);
   const relationshipData = await parseRelationshipSchemas(rootPath, objectData);
 
-  // Call Schema Generators (Phase 1)
   const generatorOptions = {
     outputPath: options.outputPath || rootPath,
     serviceTag
   };
+
   await generateSystemTextSchemas(
     objectData,
     relationshipData,
@@ -56,8 +58,66 @@ export async function generateSchema(rootPath, options) {
   await generatePropertyValueRelationshipSchemas(objectData, generatorOptions);
   await generateAttributeTreeObjectSchemas(objectData, generatorOptions);
   await generateAttributeTreeRelationshipSchemas(objectData, generatorOptions);
+}
 
-  console.log(
-    '[INFO] [generateSchema] STATUS=FINISHED | Dynamic schemas generated.'
-  );
+function readServiceTag(configPath) {
+  try {
+    const serviceConfigStr = fs.readFileSync(configPath, 'utf8');
+    const serviceConfig = yaml.parse(serviceConfigStr);
+    return serviceConfig?.main_config?.iz_serviceTag || 'unknownService';
+  } catch {
+    console.warn(
+      `[WARNING] Could not read service config at ${configPath}. Using default serviceTag.`
+    );
+    return 'unknownService';
+  }
+}
+
+function applySchemaTemplateConfig(objectData, schemaTemplateConfig, defaultServiceTag) {
+  const templates = Array.isArray(schemaTemplateConfig)
+    ? schemaTemplateConfig
+    : [];
+
+  for (const template of templates) {
+    if (template?.generateName !== 'mainAttributeTree') {
+      continue;
+    }
+
+    const objectType = template?.objType?.objectType;
+    const serviceTag = template?.objType?.serviceTag || defaultServiceTag;
+    const attributeTag = template?.attributeTag;
+
+    if (!objectType || !attributeTag) {
+      continue;
+    }
+
+    const objectSchema = objectData.objects.find(
+      obj =>
+        obj.objectType === objectType &&
+        (obj.serviceTag || defaultServiceTag) === serviceTag
+    );
+
+    if (!objectSchema) {
+      console.warn(
+        `[WARNING] [generateSchema] Template target not found for ${serviceTag}.${objectType}`
+      );
+      continue;
+    }
+
+    objectSchema.addOnDataStructure ||= [];
+
+    const hasAttributeTree = objectSchema.addOnDataStructure.some(
+      addOn =>
+        addOn?.type === 'attributeTree' &&
+        addOn?.attributeTreeTag === attributeTag
+    );
+
+    if (!hasAttributeTree) {
+      // ponytail: inject the same addon shape the existing generators already understand
+      objectSchema.addOnDataStructure.push({
+        type: 'attributeTree',
+        attributeTreeTag: attributeTag
+      });
+    }
+  }
 }

package/src/intTestGeneratorShared.js

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, rmSync } from 'fs';
+import { existsSync, readdirSync, readFileSync, rmSync } from 'fs';
 import { join } from 'path';
 import yaml from 'yaml';
 
@@ -8,24 +8,54 @@ function getServiceTag(rootPath) {
   return config?.main_config?.iz_serviceTag;
 }
 
+function getIntTestOutputPath(outputPath, projectRootPath = outputPath) {
+  return existsSync(join(projectRootPath, 'app'))
+    ? join(outputPath, 'app', 'src', 'generateIntegrationTest')
+    : join(outputPath, 'src', 'generateIntegrationTest');
+}
+
+function clearSavePath(savePath, preserveFileNames = []) {
+  if (!savePath || !existsSync(savePath)) return;
+
+  const preserved = new Set(preserveFileNames);
+  for (const entry of readdirSync(savePath)) {
+    if (preserved.has(entry)) continue;
+    rmSync(join(savePath, entry), { recursive: true, force: true });
+  }
+}
+
 async function runTemplateItems(items, { writeSource, errorPrefix }) {
+  const normalizedItems = (items || []).filter(
+    item => !(Array.isArray(item) && item.length === 0)
+  );
+  if (!normalizedItems.length) {
+    return;
+  }
+
   const clearedPaths = new Set();
 
-  for (const item of items) {
+  for (const item of normalizedItems) {
     if (!item || !item.templatePath || !item.templateData || !item.setting) {
-      throw new Error(`Invalid ${errorPrefix} item: missing templatePath/templateData/setting`);
+      throw new Error(
+        `Invalid ${errorPrefix} item: missing templatePath/templateData/setting`
+      );
     }
 
-    const [status, error] = await writeSource(item, { checkCreateSourcePass: true });
+    const [status, error] = await writeSource(item, {
+      checkCreateSourcePass: true
+    });
     if (!status) {
-      throw new Error(`${errorPrefix} template validation failed: ${error?.message || error}`);
+      throw new Error(
+        `${errorPrefix} template validation failed: ${error?.message || error}`
+      );
     }
   }
 
-  for (const item of items) {
+  for (const item of normalizedItems) {
     const savePath = item.setting?.savePath;
-    if (savePath && existsSync(savePath) && !clearedPaths.has(savePath)) {
-      rmSync(savePath, { recursive: true, force: true });
+    const cleanSavePathEnabled = item.setting?.cleanSavePath !== false;
+    if (savePath && cleanSavePathEnabled && !clearedPaths.has(savePath)) {
+      clearSavePath(savePath, item.setting?.preserveFileNames || []);
       clearedPaths.add(savePath);
     }
 
@@ -33,4 +63,4 @@ async function runTemplateItems(items, { writeSource, errorPrefix }) {
   }
 }
 
-export { getServiceTag, runTemplateItems };
+export { getIntTestOutputPath, getServiceTag, runTemplateItems };

package/src/parsers/flowSchemaParser.js

@@ -20,6 +20,8 @@ export async function parseFlowSchemas(rootPath, hydratedObjectData, options = {
     const flowsResponse = await getObjectSchema.getAllLocalFlowSchemas(_izContext, schemasPath);
     let flows = flowsResponse.records || [];
 
+    const seenFlowTags = new Set(flows.map(f => f.flowTag));
+
     // Also read dynamic flows from generateCode directory in the output path
     const targetSchemasDir = options.outputPath ? path.join(options.outputPath, 'app', 'src', 'schemas') : schemasPath;
     const dynamicSchemasPath = path.join(targetSchemasDir, 'FlowSchemas', 'generateCode');
@@ -32,8 +34,12 @@ export async function parseFlowSchemas(rootPath, hydratedObjectData, options = {
                 const filePath = path.join(dynamicSchemasPath, file);
                 const mod = await import(pathToFileURL(filePath).href);
                 if (mod.default) {
+                    if (seenFlowTags.has(mod.default.flowTag)) {
+                        continue;
+                    }
                     console.log(`[flowSchemaParser] Loaded dynamic flow: ${mod.default.flowTag}`);
                     flows.push(mod.default);
+                    seenFlowTags.add(mod.default.flowTag);
                 } else {
                     console.log(`[flowSchemaParser] No default export in ${file}`);
                 }

package/src/schemaGenerators/app/src/schemas/ObjectSchemas/templates/DynamicAttributeTreeStandardSchemaTemplate.ejs

@@ -6,8 +6,8 @@ export default [
   {
     objectType: '<%= objectType %>',
     addOnDataStructure: [],
-    canDelete: true,
     storageResources: <%- storageResources %>,
+    fieldNames: {},
     extendObjType: <%- extendObjType %>
   }
 ];