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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izara_project/izara-core-generate-service-code",
-  "version": "1.0.58",
+  "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

@@ -1,6 +1,7 @@
 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';
 
@@ -33,7 +34,8 @@ describe('getIntTestConfig path resolution', () => {
   });
 
   it('Case 2: should resolve correctly when rootPath is repo root with app/src/... structure', async () => {
-    const tmpDir = path.join(process.cwd(), 'src', '__tests__', 'scratch_tmp');
+    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 {

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/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',
@@ -107,19 +108,24 @@ async function writeSource({ templatePath, templateData, setting }, { checkCreat
 
 /**
  * Result-Driven generator to generate Integration Tests.
- * Does not have createSource/libs dependencies.
+ * 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}>}
+ * @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: () => {},
@@ -136,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,
@@ -148,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) {
@@ -47,16 +48,23 @@ function writeSource({ templatePath, templateData, setting }, { checkCreateSourc
 
 /**
  * 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}>}
+ * @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: () => {},
@@ -73,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, {
@@ -81,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

@@ -46,14 +46,28 @@ async function generateCodeWithTemplate(_izContext, savePath, settings) {
       'generateIntegrationTest/libs/',
       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/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/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}`);
                 }