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

package/src/codeGenerators/app/src/generatedCode/Flow/_internal/shared/triggerCacheBase.js

@@ -0,0 +1,183 @@
+import path from 'path';
+import fs from 'fs/promises';
+import { fileURLToPath } from 'url';
+import ejs from 'ejs';
+import { getFlowOutputSubDir } from './flowClassifier.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+function upperCase(str) {
+    if (!str) return str;
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+function shortNameHandler(handlerType) {
+    const map = {
+        'HdrSqs': 'Sqs',
+        'HdrApi': 'Api',
+        'HdrWbs': 'Wbs',
+        'HdrDsq': 'Dsq'
+    };
+    return map[handlerType] || handlerType;
+}
+
+export async function generateTriggerCache(flowSchema, appPath, outputBaseDir) {
+    const flowTag = flowSchema.flowTag;
+    const upperFlowTag = upperCase(flowTag);
+    const serviceTag = flowSchema.objType?.serviceTag || 'UnknownService';
+    const templateDir = path.join(__dirname, '..', '_shared', 'triggerCache');
+
+    const subDir = getFlowOutputSubDir(flowTag);
+
+    const flowOutputDir = path.join(outputBaseDir, 'app', 'src', 'generatedCode', subDir, upperFlowTag, 'source');
+    await fs.mkdir(flowOutputDir, { recursive: true });
+
+    const slsYamlDir = path.join(outputBaseDir, 'app', 'sls_yaml', 'generatedCode', 'source');
+    await fs.mkdir(slsYamlDir, { recursive: true });
+
+    const resourceYamlDir = path.join(outputBaseDir, 'resource', 'sls_yaml', 'generatedCode', 'source');
+    await fs.mkdir(resourceYamlDir, { recursive: true });
+
+    const additionalResourcePermission = [];
+
+    const templates = {
+        processMain: await fs.readFile(path.join(templateDir, 'ProcessTriggerCache_Main.ejs'), 'utf-8'),
+        processHandler: await fs.readFile(path.join(templateDir, 'ProcessTriggerCache_HdrSqs.ejs'), 'utf-8'),
+        processYaml: await fs.readFile(path.join(templateDir, '..', 'yaml', 'SharedFunctionSqs_Yaml.ejs'), 'utf-8'),
+
+        checkMain: await fs.readFile(path.join(templateDir, 'CheckTriggerCache_Main.ejs'), 'utf-8'),
+        checkHandler: await fs.readFile(path.join(templateDir, 'CheckTriggerCache_HdrSqs.ejs'), 'utf-8'),
+        checkYaml: await fs.readFile(path.join(templateDir, '..', 'yaml', 'SharedFunctionSqs_Yaml.ejs'), 'utf-8'),
+
+        completeMain: await fs.readFile(path.join(templateDir, 'TriggerCacheComplete_Main.ejs'), 'utf-8'),
+        completeHandlerSqs: await fs.readFile(path.join(templateDir, 'TriggerCacheComplete_HdrSqs.ejs'), 'utf-8'),
+        completeHandlerDsq: await fs.readFile(path.join(templateDir, 'TriggerCacheComplete_HdrDsq.ejs'), 'utf-8'),
+        completeYamlSqs: await fs.readFile(path.join(templateDir, '..', 'yaml', 'SharedFunctionSqs_Yaml.ejs'), 'utf-8'),
+        completeYamlDsq: await fs.readFile(path.join(templateDir, '..', 'yaml', 'SharedFunctionSqs_Yaml.ejs'), 'utf-8'),
+
+        queueYaml: await fs.readFile(path.join(templateDir, 'TriggerCacheQueue_Yaml.ejs'), 'utf-8')
+    };
+
+    // Helper to render and write
+    async function renderAndWrite(tplContent, outPath, data) {
+        const content = ejs.render(tplContent, data);
+        await fs.writeFile(outPath, content, 'utf-8');
+    }
+
+    async function renderAndAppend(tplContent, outPath, data) {
+        const content = ejs.render(tplContent, data);
+        await fs.appendFile(outPath, '\n' + content, 'utf-8');
+    }
+
+    // 1. ProcessTriggerCache
+    {
+        const functionName = 'ProcessTriggerCache' + upperFlowTag;
+        const handlerType = 'HdrDsq';
+        const queueName = `${serviceTag}${upperFlowTag}_Main`;
+
+        const data = {
+            functionName, handlerType, queueName,
+            upperFunctionName: upperCase(functionName), upperQueueName: upperCase(queueName),
+            upperHandlerType: upperCase(handlerType), flowType: flowTag, flowTag: flowTag,
+            resourceLocation: `src/generatedCode/${subDir}/${upperFlowTag}/source/`,
+            handlerPath: `src/generatedCode/${subDir}/${upperFlowTag}/source/${functionName}_${handlerType}.main`,
+            handlerPathUpperFunctionName: `src/generatedCode/${subDir}/${upperFlowTag}/source/${upperCase(functionName)}_${upperCase(handlerType)}.main`,
+            roleName: upperFlowTag, upperRoleName: upperCase(upperFlowTag),
+            functionNameConfig: upperCase(functionName) + upperCase(shortNameHandler(handlerType)),
+            additionalResourcePermission
+        };
+
+        await renderAndWrite(templates.processMain, path.join(flowOutputDir, `${functionName}_Main.js`), data);
+        await renderAndWrite(templates.processHandler, path.join(flowOutputDir, `${functionName}_${handlerType}.js`), data);
+        await renderAndAppend(templates.processYaml, path.join(slsYamlDir, 'flow-schema.yml'), data);
+    }
+
+    // 2. CheckTriggerCacheComplete
+    {
+        const functionName = 'CheckTriggerCache' + upperFlowTag + 'Complete';
+        const handlerType = 'HdrSqs';
+        const queueName = functionName + handlerType;
+
+        const data = {
+            functionName, handlerType, queueName,
+            upperFunctionName: upperCase(functionName), upperQueueName: upperCase(queueName),
+            upperHandlerType: upperCase(handlerType), flowType: flowTag, flowTag: flowTag,
+            resourceLocation: `src/generatedCode/${subDir}/${upperFlowTag}/source/`,
+            handlerPath: `src/generatedCode/${subDir}/${upperFlowTag}/source/${functionName}_${handlerType}.main`,
+            handlerPathUpperFunctionName: `src/generatedCode/${subDir}/${upperFlowTag}/source/${upperCase(functionName)}_${upperCase(handlerType)}.main`,
+            roleName: upperFlowTag, upperRoleName: upperCase(upperFlowTag),
+            functionNameConfig: upperCase(functionName) + upperCase(shortNameHandler(handlerType)),
+            additionalResourcePermission
+        };
+
+        await renderAndWrite(templates.checkMain, path.join(flowOutputDir, `${functionName}_Main.js`), data);
+        await renderAndWrite(templates.checkHandler, path.join(flowOutputDir, `${functionName}_${handlerType}.js`), data);
+        await renderAndAppend(templates.checkYaml, path.join(slsYamlDir, 'flow-schema.yml'), data);
+    }
+
+    // 3. TriggerCacheComplete
+    {
+        const functionName = 'TriggerCache' + upperFlowTag + 'Complete';
+
+        // Main
+        await renderAndWrite(templates.completeMain, path.join(flowOutputDir, `${functionName}_Main.js`), {
+            functionName, flowType: flowTag, flowTag: flowTag, upperFunctionName: upperCase(functionName)
+        });
+
+        // SQS Variant
+        {
+            const handlerType = 'HdrSqs';
+            const queueName = functionName + handlerType;
+            const data = {
+                functionName, handlerType, queueName,
+                upperFunctionName: upperCase(functionName), upperQueueName: upperCase(queueName),
+                upperHandlerType: upperCase(handlerType), flowType: flowTag,
+                resourceLocation: `src/generatedCode/${subDir}/${upperFlowTag}/source/`,
+                handlerPath: `src/generatedCode/${subDir}/${upperFlowTag}/source/${functionName}_${handlerType}.main`,
+                handlerPathUpperFunctionName: `src/generatedCode/${subDir}/${upperFlowTag}/source/${upperCase(functionName)}_${upperCase(handlerType)}.main`,
+                roleName: upperFlowTag, upperRoleName: upperCase(upperFlowTag),
+                functionNameConfig: upperCase(functionName) + upperCase(shortNameHandler(handlerType)),
+                additionalResourcePermission
+            };
+            await renderAndWrite(templates.completeHandlerSqs, path.join(flowOutputDir, `${functionName}_${handlerType}.js`), data);
+            await renderAndAppend(templates.completeYamlSqs, path.join(slsYamlDir, 'flow-schema.yml'), data);
+        }
+
+        // DSQ Variant
+        {
+            const handlerType = 'HdrDsq';
+            const queueName = functionName + handlerType;
+            const data = {
+                functionName, handlerType, queueName,
+                upperFunctionName: upperCase(functionName), upperQueueName: upperCase(queueName),
+                upperHandlerType: upperCase(handlerType), flowType: flowTag,
+                resourceLocation: `src/generatedCode/${subDir}/${upperFlowTag}/source/`,
+                handlerPath: `src/generatedCode/${subDir}/${upperFlowTag}/source/${functionName}_${handlerType}.main`,
+                handlerPathUpperFunctionName: `src/generatedCode/${subDir}/${upperFlowTag}/source/${upperCase(functionName)}_${upperCase(handlerType)}.main`,
+                roleName: upperFlowTag, upperRoleName: upperCase(upperFlowTag),
+                functionNameConfig: upperCase(functionName) + upperCase(shortNameHandler(handlerType)),
+                additionalResourcePermission
+            };
+            await renderAndWrite(templates.completeHandlerDsq, path.join(flowOutputDir, `${functionName}_${handlerType}.js`), data);
+            await renderAndAppend(templates.completeYamlDsq, path.join(slsYamlDir, 'flow-schema.yml'), data);
+        }
+    }
+
+    // 4. TriggerCacheQueue
+    {
+        const queueNames = [
+            `${serviceTag}${upperFlowTag}_Main`,
+            'CheckTriggerCache' + upperFlowTag + 'CompleteHdrSqs',
+            'TriggerCache' + upperFlowTag + 'CompleteHdrSqs',
+            'TriggerCache' + upperFlowTag + 'CompleteHdrDsq'
+        ];
+
+        for (const queueName of queueNames) {
+            const resourceQueueName = queueName.includes("_") ? queueName.split("_").join("") : queueName;
+            await renderAndAppend(templates.queueYaml, path.join(resourceYamlDir, 'generated-sns-in-sqs.yml'), { queueName, resourceQueueName });
+        }
+    }
+
+    console.log(`  [TriggerCacheGenerator] Generated triggerCache files for flow: ${flowTag}`);
+}

package/src/codeGenerators/app/src/generatedCode/ProcessLogical/ProcessLogicalGenerator.js

@@ -0,0 +1,26 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export async function generateProcessLogical(options) {
+    console.log('  [ProcessLogicalGenerator] Generating ProcessLogical flows...');
+    
+    const outputDir = path.join(options.outputPath, 'app', 'src', 'generatedCode', 'ProcessLogical', 'source');
+    await fs.mkdir(outputDir, { recursive: true });
+
+    const templatesDir = path.join(__dirname, 'templates');
+    const files = await fs.readdir(templatesDir);
+
+    for (const file of files) {
+        if (file.endsWith('.js')) {
+            const sourceFile = path.join(templatesDir, file);
+            const destFile = path.join(outputDir, file);
+            await fs.copyFile(sourceFile, destFile);
+        }
+    }
+    
+    console.log(`  [ProcessLogicalGenerator] Wrote ${files.length} ProcessLogical files.`);
+}

package/src/{generators/fromObjectSchema/processLogicalPagination/handler/dsq/template.ejs → codeGenerators/app/src/generatedCode/ProcessLogical/templates/PaginateProcessLogical_HdrDsq.js}

@@ -174,4 +174,4 @@ export const main = middleware.wrap(async (event, context, callback) => {
     Logger.error('Unhandled Error, PaginateProcessLogicalHdrDsq: ', err);
     throw err;
   }
-});
+});

package/src/{generators/fromObjectSchema/processLogicalPagination/handler/sqs/template.ejs → codeGenerators/app/src/generatedCode/ProcessLogical/templates/PaginateProcessLogical_HdrSqs.js}

@@ -152,4 +152,4 @@ export const main = middleware.wrap(async (event, context, callback) => {
     Logger.error('Unhandled Error, PaginateProcessLogicalHdrSqs: ', err);
     throw err;
   }
-});
+});

package/src/{generators/fromObjectSchema/processLogicalPagination/mainFunction/template.ejs → codeGenerators/app/src/generatedCode/ProcessLogical/templates/PaginateProcessLogical_Main.js}

@@ -73,15 +73,15 @@ export default async function paginateProcessLogical(
 
     // Check/Create logicalResultsMain
     let [checkUniqueRequestProcessingStatus, logicalResultsMain] =
-      await asyncFlowSharedLib.checkUniqueRequestProcessing(
-        _izContext,
-        'LogicalResultsMain',
-        {
-          logicalResultId: logicalResultId
-        },
-        'paginateProcessLogical',
-        overwriteUniqueRequestId
-      );
+    await asyncFlowSharedLib.checkUniqueRequestProcessing(
+      _izContext,
+      'LogicalResultsMain',
+      {
+        logicalResultId: logicalResultId
+      },
+      'paginateProcessLogical',
+      overwriteUniqueRequestId
+    );
     _izContext.logger.debug('After check uniqueRequestProcessingStatus:', {
       checkUniqueRequestProcessingStatus: checkUniqueRequestProcessingStatus,
       logicalResultsMain: logicalResultsMain
@@ -265,4 +265,4 @@ export default async function paginateProcessLogical(
     _izContext.logger.error('error PaginateProcessLogicalMain: ', err);
     throw err;
   }
-}
+}

package/src/{generators/fromObjectSchema/processLogical/handler/template.ejs → codeGenerators/app/src/generatedCode/ProcessLogical/templates/ProcessLogical_HdrSqs.js}

@@ -128,4 +128,4 @@ export const main = middleware.wrap(async (event, context, callback) => {
     Logger.error('Unhandled Error, ProcessLogicalHdrSqs: ', err);
     throw err;
   }
-});
+});

package/src/{generators/fromObjectSchema/processLogical/mainFunction/template.ejs → codeGenerators/app/src/generatedCode/ProcessLogical/templates/ProcessLogical_Main.js}

@@ -73,14 +73,14 @@ export default async function processLogical(
 
     // Check/Create logicalResultsMain
     let [logicalResultsMainStatus, logicalResultId, logicalResultMain] =
-      await logicalResultsSharedLib.checkLogicalMainStatus(
-        _izContext,
-        element, // for create logicalResultId
-        objType,
-        callingFlow,
-        removeAttributes,
-        overWriteCache
-      );
+    await logicalResultsSharedLib.checkLogicalMainStatus(
+      _izContext,
+      element, // for create logicalResultId
+      objType,
+      callingFlow,
+      removeAttributes,
+      overWriteCache
+    );
     _izContext.logger.debug('After check logicalMainStatus: ', {
       logicalResultsMainStatus: logicalResultsMainStatus,
       logicalResultId: logicalResultId,
@@ -170,8 +170,8 @@ export default async function processLogical(
     const storageResources = objectSchemas.storageResources;
 
     storageResourcesLoop: for (const storageResourceTag of Object.keys(
-      storageResources
-    )) {
+        storageResources
+      )) {
       _izContext.logger.debug('check storageResourceTag: ', storageResourceTag);
 
       if (
@@ -203,7 +203,7 @@ export default async function processLogical(
             let conditionalFieldName = conditionalFieldValue.fieldName;
             let storageResourceTagsFieldName =
               objectSchemas.fieldNames[conditionalFieldName]
-                .storageResourceTags;
+              .storageResourceTags;
 
             if (storageResourceTagsFieldName.includes(storageResourceTag)) {
               continue conditionalFieldValuesLoop;
@@ -250,16 +250,16 @@ export default async function processLogical(
     // concatenate partitionKey
     let partitionKeyReqIdentifiers = {};
     for (const [fieldName, fieldNameValue] of Object.entries(
-      element.partitionKeyValues
-    )) {
+        element.partitionKeyValues
+      )) {
       partitionKeyReqIdentifiers[fieldName] = fieldNameValue.value;
     }
 
     // concatenate sortKey
     if (element.hasOwnProperty('sortKeyValues')) {
       for (const [fieldName, fieldNameValue] of Object.entries(
-        element.sortKeyValues
-      )) {
+          element.sortKeyValues
+        )) {
         partitionKeyReqIdentifiers[fieldName] = fieldNameValue.value;
       }
     }
@@ -447,4 +447,4 @@ export default async function processLogical(
     _izContext.logger.error('error ProcessLogicalMain: ', err);
     throw err;
   }
-}
+}

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

@@ -0,0 +1,166 @@
+import path from 'path';
+import fs from 'fs/promises';
+import { fileURLToPath } from 'url';
+import ejs from 'ejs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+function upperCase(str) {
+    if (!str) return str;
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+function shortNameHandler(handlerType) {
+    const map = {
+        'HdrSqs': 'Sqs',
+        'HdrApi': 'Api',
+        'HdrWbs': 'Wbs',
+        'HdrDsq': 'Dsq'
+    };
+    return map[handlerType] || handlerType;
+}
+
+export async function generateRegisterFlow(allLocalFlowSchemas, appPath, outputBaseDir) {
+    const hasRegisterFlow = allLocalFlowSchemas.some(flow => flow.flowTag === 'Register');
+    if (!hasRegisterFlow) {
+        console.log('  [RegisterGenerator] No Register flow descriptor found. Skipping.');
+        return;
+    }
+
+    console.log('  [RegisterGenerator] Generating Register flow files...');
+    const templatesDir = path.join(__dirname, 'templates', 'register');
+    const wsTemplatesDir = path.join(__dirname, '..', 'Flow', 'FlowSchemas', 'templates', 'webSocket');
+    
+    // Output paths
+    const registerDir = path.join(outputBaseDir, 'app', 'src', 'generatedCode', 'SystemFlowSchemas', 'Register', 'source');
+    await fs.mkdir(registerDir, { recursive: true });
+
+    const slsYamlDir = path.join(outputBaseDir, 'app', 'sls_yaml', 'generatedCode', 'source');
+    await fs.mkdir(slsYamlDir, { recursive: true });
+
+    const resourceYamlDir = path.join(outputBaseDir, 'resource', 'sls_yaml', 'generatedCode', 'source');
+    await fs.mkdir(resourceYamlDir, { recursive: true });
+
+    // Helper to render and write
+    async function renderAndWrite(tplPath, outPath, data) {
+        const tpl = await fs.readFile(tplPath, 'utf-8');
+        const content = ejs.render(tpl, data);
+        await fs.writeFile(outPath, content, 'utf-8');
+    }
+
+    async function renderAndAppend(tplPath, outPath, data) {
+        const tpl = await fs.readFile(tplPath, 'utf-8');
+        const content = ejs.render(tpl, data);
+        await fs.appendFile(outPath, '\n' + content, 'utf-8');
+    }
+
+    // 1. WBS Handler and Main
+    const wbsFunctionName = 'Register';
+    await renderAndWrite(
+        path.join(templatesDir, 'Register_Main.ejs'),
+        path.join(registerDir, `${wbsFunctionName}_Main.js`),
+        { functionMain: `${wbsFunctionName}_Main` }
+    );
+    
+    await renderAndWrite(
+        path.join(templatesDir, 'Register_HdrWbs.ejs'),
+        path.join(registerDir, `${wbsFunctionName}_HdrWbs.js`),
+        { routeName: 'register' }
+    );
+
+    const wbsYamlTemplatePath = path.join(__dirname, '..', '..', '..', 'sls_yaml', 'templates', 'FunctionYaml_Wbs.ejs');
+    await renderAndAppend(
+        wbsYamlTemplatePath, 
+        path.join(slsYamlDir, 'flow-schema.yml'),
+        {
+            functionNameConfig: wbsFunctionName + 'Wbs',
+            handlerPath: `src/generatedCode/SystemFlowSchemas/Register/source/${wbsFunctionName}_HdrWbs.main`,
+            roleName: 'RegisterRole',
+            routeName: 'register'
+        }
+    );
+
+    // 2. Complete Handler and Main
+    const completeFunctionName = 'RegisterComplete';
+    const processHandlerType = 'HdrSqs';
+    const queueName = completeFunctionName;
+
+    const completeData = {
+        functionName: completeFunctionName,
+        handlerType: processHandlerType,
+        queueName: queueName,
+        handlerFilePath: `src/generatedCode/SystemFlowSchemas/Register/source/${completeFunctionName}_${processHandlerType}`,
+        roleName: 'RegisterComplete',
+        upperFunctionName: upperCase(completeFunctionName),
+        upperHandlerType: upperCase(processHandlerType),
+        upperQueueName: upperCase(queueName),
+        functionNameConfig: upperCase(completeFunctionName) + upperCase(shortNameHandler(processHandlerType))
+    };
+
+    await renderAndWrite(
+        path.join(templatesDir, 'RegisterComplete_Main.ejs'),
+        path.join(registerDir, `${completeFunctionName}_Main.js`),
+        completeData
+    );
+
+    await renderAndWrite(
+        path.join(templatesDir, 'RegisterComplete_HdrSqs.ejs'),
+        path.join(registerDir, `${completeFunctionName}_${processHandlerType}.js`),
+        completeData
+    );
+    
+    // Also generate Dsq if needed, or legacy only had Sqs?
+    // Legacy RegisterComplete_HdrSqs template does both Sqs and Dsq based on yaml, but here we just write HdrSqs and HdrDsq.
+    await renderAndWrite(
+        path.join(templatesDir, 'RegisterComplete_HdrSqs.ejs'),
+        path.join(registerDir, `${completeFunctionName}_HdrDsq.js`),
+        { ...completeData, handlerType: 'HdrDsq' }
+    );
+
+    // Append to flow-schema.yml
+    await renderAndAppend(
+        path.join(wsTemplatesDir, 'ProcessWebSocketFlow_Yaml.ejs'),
+        path.join(slsYamlDir, 'flow-schema.yml'),
+        completeData
+    );
+
+    // Append Dsq to flow-schema
+    await renderAndAppend(
+        path.join(wsTemplatesDir, 'ProcessWebSocketFlow_Yaml.ejs'),
+        path.join(slsYamlDir, 'flow-schema.yml'),
+        {
+            ...completeData,
+            handlerType: 'HdrDsq',
+            upperHandlerType: 'HDRDSQ',
+            functionNameConfig: upperCase(completeFunctionName) + 'Dsq',
+            handlerFilePath: `src/generatedCode/SystemFlowSchemas/Register/source/${completeFunctionName}_HdrDsq`,
+        }
+    );
+
+    // 3. SQS and SNS Subscriptions
+    // We reuse ProcessWebSocket_Yaml.ejs which creates SQS queue
+    await renderAndAppend(
+        path.join(wsTemplatesDir, 'ProcessWebSocket_Yaml.ejs'),
+        path.join(resourceYamlDir, 'generated-sns-in-sqs.yml'),
+        completeData
+    );
+
+    // RegisterComplete subscribes to ALL output topics
+    for (const flowSchema of allLocalFlowSchemas) {
+        if (flowSchema.outputTopic) {
+            const topicOut = upperCase(flowSchema.flowTag);
+            await renderAndAppend(
+                path.join(wsTemplatesDir, 'ProcessWebSocketSub_Yaml.ejs'),
+                path.join(resourceYamlDir, 'generated-sns-in-sqs.yml'),
+                {
+                    subscribeTo: topicOut,
+                    queueName: queueName,
+                    upperQueueName: upperCase(queueName)
+                }
+            );
+        }
+    }
+
+    console.log(`  [RegisterGenerator] Finished generating Register flow files.`);
+}

package/src/{generators/fromFlowSchema/register/wbs/handler/template.ejs → codeGenerators/app/src/generatedCode/SystemFlowSchemas/templates/register/Register_HdrWbs.ejs}

@@ -77,8 +77,4 @@ export const main = middleware.wrap(async (event, context) => {
     await postToConnection({ message: err.message }, connId);
     return (response.failure(err));
   }
-});
-<%_ const join = require('path').join _%>
-<%_ function upperCase (text) {
-  return text.charAt(0).toUpperCase() + text.slice(1)
-  } _%>
+});

package/src/codeGenerators/app/src/generatedCode/libs/ConstsGenerator.js

@@ -0,0 +1,20 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export async function generateConsts(options) {
+    console.log('  [ConstsGenerator] Generating Consts...');
+
+    const outputDir = path.join(options.outputPath, 'app', 'src', 'generatedCode', 'libs', 'source');
+    await fs.mkdir(outputDir, { recursive: true });
+
+    const sourceFile = path.join(__dirname, 'templates', 'Consts.js');
+    const destFile = path.join(outputDir, 'Consts.js');
+
+    await fs.copyFile(sourceFile, destFile);
+
+    console.log(`  [ConstsGenerator] Wrote Consts.js`);
+}

package/src/codeGenerators/app/src/generatedCode/libs/GenerateCodeLibsGenerator.js

@@ -0,0 +1,20 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export async function generateCodeLibs(options) {
+    console.log('  [GenerateCodeLibsGenerator] Generating Code Libs...');
+    
+    const outputDir = path.join(options.outputPath, 'app', 'src', 'generatedCode', 'libs', 'source');
+    await fs.mkdir(outputDir, { recursive: true });
+
+    const sourceFile = path.join(__dirname, 'templates', 'GenerateCodeLibs.js');
+    const destFile = path.join(outputDir, 'GenerateCodeLibs.js');
+
+    await fs.copyFile(sourceFile, destFile);
+    
+    console.log(`  [GenerateCodeLibsGenerator] Wrote GenerateCodeLibs.js`);
+}