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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izara_project/izara-core-generate-service-code",
-  "version": "1.0.57",
+  "version": "1.0.58",
   "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,49 @@
+import { describe, it, expect, jest, beforeEach, afterEach } from '@jest/globals';
+import path from 'path';
+import fs from 'fs';
+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(process.cwd(), 'src', '__tests__', 'scratch_tmp');
+    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/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

@@ -105,6 +105,17 @@ async function writeSource({ templatePath, templateData, setting }, { checkCreat
   return [true, {}];
 }
 
+/**
+ * Result-Driven generator to generate Integration Tests.
+ * Does not have createSource/libs dependencies.
+ *
+ * @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 {object} [options._izContext] - Integration context containing logger interface.
+ * @returns {Promise<{serviceTag: string, count: number, durationMs: number}>}
+ */
 export async function generateIntTest(rootPath, options = {}) {
   const {
     outputPath = rootPath,

package/src/generateResourceIntTest.js

@@ -45,6 +45,15 @@ function writeSource({ templatePath, templateData, setting }, { checkCreateSourc
   return [true, {}];
 }
 
+/**
+ * Result-Driven generator to generate Integration Test resources.
+ *
+ * @param {string} rootPath - The root path of the project.
+ * @param {object} [options={}] - Configuration options.
+ * @param {string} [options.outputPath] - Output directory path.
+ * @param {object} [options._izContext] - Integration context containing logger interface.
+ * @returns {Promise<{serviceTag: string, count: number, durationMs: number}>}
+ */
 export async function generateResourceIntTest(rootPath, options = {}) {
   const {
     outputPath = rootPath,

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

@@ -44,7 +44,7 @@ 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);

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/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/schemaGenerators/app/src/schemas/ObjectSchemas/templates/DynamicAttributeTreeStandardSchemaTemplate.ejs

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