@izara_project/izara-core-generate-service-code 1.0.93 → 1.0.94

package/src/emit/custom/templates/FlowEndpoint_Main.ejs

@@ -26,6 +26,9 @@ import lambdaSharedLib from '@izara_project/izara-core-library-lambda';
 <% if (typeof flow !== 'undefined' && flow.statusType === 'storedCache') { %>
 import storedCacheSharedLib from '@izara_project/izara-core-library-stored-cache';
 <% } %>
+<% if (typeof flow !== 'undefined' && flow.statusType === 'triggerCache') { %>
+import { triggeredCacheSharedLibV2 } from '@izara_project/izara-core-library-trigger-cache';
+<% } %>
 
 //(<optionalImport>)
 import { getObjectSchema } from '@izara_project/izara-core-library-service-schemas';
@@ -73,6 +76,70 @@ export default async function <%- typeof functionName !== 'undefined' ? function
       callingFlowConfig
     );
 
+<% if (typeof flow !== 'undefined' && flow.statusType === 'triggerCache') { -%>
+
+    //(<beforeCheckTriggeredCache>)
+    //(</beforeCheckTriggeredCache>)
+
+    const checkTriggerReseted =
+      await triggeredCacheSharedLibV2.checkTriggerResetedV2(
+        _izContext,
+        {
+          serviceTag: process.env.iz_serviceTag,
+          flowTag: '<%= flowTag %>'
+        },
+        //(<triggerCacheIdentifiers>)
+        {}
+        //(</triggerCacheIdentifiers>)
+        //(<triggerCacheUniqueRequestId>)
+        //(</triggerCacheUniqueRequestId>)
+        //(<triggerCacheSettings>)
+        //(</triggerCacheSettings>)
+      );
+
+    _izContext.logger.debug(
+      `[${process.env.iz_serviceTag}:<%-
+        typeof functionName !== 'undefined'
+          ? functionName
+          : upperCaseFlowTag
+      %>] checkTriggerReseted:`,
+      checkTriggerReseted
+    );
+
+    //(<afterCheckTriggerReseted>)
+    //(</afterCheckTriggerReseted>)
+
+    const triggeredCacheResult =
+      await triggeredCacheSharedLibV2.checkTriggeredCacheV2(
+        _izContext,
+        {
+          serviceTag: process.env.iz_serviceTag,
+          flowTag: '<%= flowTag %>'
+        },
+        //(<triggerCacheCheckIdentifiers>)
+        {}
+        //(</triggerCacheCheckIdentifiers>)
+      );
+
+    _izContext.logger.debug(
+      `[${process.env.iz_serviceTag}:<%-
+        typeof functionName !== 'undefined'
+          ? functionName
+          : upperCaseFlowTag
+      %>] triggeredCacheResult:`,
+      triggeredCacheResult
+    );
+
+    //(<afterCheckTriggeredCache>)
+    //(</afterCheckTriggeredCache>)
+
+    if (triggeredCacheResult?.hasPendingTasks) {
+      //(<dispatchTriggerFlowHook>)
+      //(</dispatchTriggerFlowHook>)
+      return triggeredCacheResult;
+    }
+
+<% } -%>
 <% if (typeof flow !== 'undefined' && flow.statusType === 'storedCache') { -%>
 
     //(<beforeCheckCache>)
@@ -107,6 +174,12 @@ export default async function <%- typeof functionName !== 'undefined' ? function
 
       //(<checkStoredCacheHook>)
       //(</checkStoredCacheHook>)
+
+      if (cacheMainStatus === 'complete') {
+        //(<returnStoredCacheHit>)
+        return cacheMain;
+        //(</returnStoredCacheHit>)
+      }
     }
 <% } -%>
 <% if (typeof flow !== 'undefined' && flow.isRbac && !flow.generatedCodeConfig) { -%>

package/src/emit/resource/iamResourceArtifacts.js

@@ -242,7 +242,11 @@ export function roleTableNames(state, roleName) {
     tables.push('UserUploadRecords', 'ReservedDataMain');
   }
   if (flow.statusType === 'storedCache') {
-    const object = state.objectTablesByType.get(flow.objType?.objectType);
+    const targetObjectType =
+      typeof flow.objType === 'string'
+        ? flow.objType
+        : flow.objType?.objectType;
+    const object = state.objectTablesByType.get(targetObjectType);
     if (object) {
       tables.push(object);
     }

package/src/emit/system/emitSystemFindDataArtifacts.js

@@ -43,13 +43,14 @@ async function _emitSystemArtifacts(objects) {
     return { artifacts: [], functions: [] };
   }
 
-  const hasFindDataEntries = buildFindDataEntries(objects).length > 0;
+  const findDataEntries = buildFindDataEntries(objects);
+  const hasFindDataEntries = findDataEntries.length > 0;
 
   const artifacts = [];
 
   if (hasFindDataEntries) {
     const findDataMain = await render('FindData_Main.ejs', {
-      datas: buildFindDataEntries(objects)
+      datas: findDataEntries
     });
     artifacts.push(
       { path: `${FIND_DATA_SOURCE}/FindData_Main.js`, content: findDataMain },
@@ -85,21 +86,21 @@ async function _emitSystemArtifacts(objects) {
 
   return {
     artifacts,
-    functions: renderSystemYamlFunctions()
+    functions: renderSystemYamlFunctions(hasFindDataEntries)
   };
 }
 
-function renderSystemYamlFunctions() {
-  const findDataYaml = renderFindDataYaml();
-  const processLogicalYaml = renderProcessLogicalYaml();
-  const processLogicalPaginateDsqYaml = renderProcessLogicalPaginateDsqYaml();
-  const processLogicalPaginateSqsYaml = renderProcessLogicalPaginateSqsYaml();
-  return [
-    findDataYaml,
-    processLogicalYaml,
-    processLogicalPaginateDsqYaml,
-    processLogicalPaginateSqsYaml
-  ];
+function renderSystemYamlFunctions(hasFindDataEntries = true) {
+  const functions = [];
+  if (hasFindDataEntries) {
+    functions.push(renderFindDataYaml());
+  }
+  functions.push(
+    renderProcessLogicalYaml(),
+    renderProcessLogicalPaginateDsqYaml(),
+    renderProcessLogicalPaginateSqsYaml()
+  );
+  return functions;
 }
 
 function renderFindDataYaml() {

package/test/core.test.js

@@ -34,6 +34,19 @@ test('compiles a request and commits only declared relative artifacts', async ()
 test('rejects invalid generation inputs before writing files', async () => {
   assert.throws(() => compileProject({}), /rootPath/);
 
+  const corruptPath = await mkdtemp(
+    join(tmpdir(), 'generate-service-code-v2-corrupt-yml-')
+  );
+  await mkdir(join(corruptPath, 'config'), { recursive: true });
+  await writeFile(
+    join(corruptPath, 'config/serverless.config.yml'),
+    'main_config: [unbalanced brackets:'
+  );
+  assert.throws(
+    () => compileProject({ rootPath: corruptPath }),
+    /Failed to read or parse configuration at/
+  );
+
   const outputPath = await mkdtemp(
     join(tmpdir(), 'generate-service-code-v2-invalid-')
   );

package/test/customFlowApplicationArtifacts.test.js

@@ -254,7 +254,7 @@ test('removes only V2-owned custom-flow application artifacts when supported eve
   await generateCustomFlowApplicationArtifacts(rootPath);
   await writeFile(
     join(rootPath, 'app/src/schemas/FlowSchemas/Flows.js'),
-    "export default [{ flowTag: 'later', event: ['unsupported'] }];\n"
+    "export default [];\n"
   );
 
   assert.deepEqual(
@@ -469,6 +469,53 @@ test('emits and removes the trigger-cache artifact suite when triggerFlowTypes i
   );
 });
 
+test('triggerCache entrypoint Cart_Main.js contains correct library import and logic', async () => {
+  const rootPath = await createTriggerCacheProject(['OrderCheckout']);
+  await generateCustomFlowApplicationArtifacts(rootPath);
+
+  const source = 'app/src/generatedCode/FlowSchemas/Cart/source';
+  const mainContent = await readFile(
+    join(rootPath, `${source}/Cart_Main.js`),
+    'utf8'
+  );
+
+  assert.match(
+    mainContent,
+    /import \{ triggeredCacheSharedLibV2 \} from '@izara_project\/izara-core-library-trigger-cache'/,
+    'should import triggeredCacheSharedLibV2'
+  );
+  assert.match(
+    mainContent,
+    /triggeredCacheSharedLibV2\.checkTriggerResetedV2/,
+    'should call checkTriggerResetedV2'
+  );
+  assert.match(
+    mainContent,
+    /triggeredCacheSharedLibV2\.checkTriggeredCacheV2/,
+    'should call checkTriggeredCacheV2'
+  );
+  assert.match(
+    mainContent,
+    /\/\/\(<beforeCheckTriggeredCache>\)/,
+    'should have beforeCheckTriggeredCache hook'
+  );
+  assert.match(
+    mainContent,
+    /\/\/\(<dispatchTriggerFlowHook>\)/,
+    'should have dispatchTriggerFlowHook hook'
+  );
+  assert.match(
+    mainContent,
+    /if \(triggeredCacheResult\?\.hasPendingTasks\)/,
+    'should guard dispatch with hasPendingTasks check'
+  );
+  assert.doesNotMatch(
+    mainContent,
+    /checkStoredCacheStatus/,
+    'should not contain storedCache logic'
+  );
+});
+
 test('uses custom CheckTrigger step if provided by developer in flowSteps', async () => {
   const rootPath = await mkdtemp(
     join(tmpdir(), 'generate-service-code-v2-trigger-cache-custom-')
@@ -494,28 +541,77 @@ test('uses custom CheckTrigger step if provided by developer in flowSteps', asyn
   assert.match(flowYaml, /^CartCheckTriggerCustomStepHdrSqs:/m);
 });
 
-test('does not emit check trigger-cache artifacts when triggerFlowTypes is empty, null, undefined, or missing', async () => {
+test('uses full {flowTag}{stepName} queue name when stepName starts with flowTag', async () => {
+  const rootPath = await createTriggerCacheProject(['OrderCheckout']);
+  await writeFile(
+    join(rootPath, 'app/src/schemas/FlowSchemas/Cart.js'),
+    "export default { flowTag: 'cart', event: ['ownTopic'], statusType: 'triggerCache', triggerFlowTypes: ['OrderCheckout'], objType: { serviceTag: 'Order' }, flowSteps: [{ stepName: 'start' }, { stepName: 'CartCheckX', event: ['extTopic'] }] };\n"
+  );
+  await generateCustomFlowApplicationArtifacts(rootPath);
+  await generateResourceArtifacts(rootPath);
+
+  const source = 'app/src/generatedCode/FlowSchemas/Cart/source';
+  for (const fileName of [
+    'CartCartCheckX_Main.js',
+    'CartCartCheckX_HdrSqs.js'
+  ]) {
+    const path = join(rootPath, source, fileName);
+    await access(path);
+    await parseAsEsm(path);
+  }
+
+  const flowYaml = await readFile(
+    join(rootPath, 'app/sls_yaml/generatedCode/source/flow-schema.yml'),
+    'utf8'
+  );
+  assert.match(flowYaml, /^CartCartCheckXHdrSqs:/m);
+  assert.match(
+    await readFile(join(rootPath, `${source}/CartCartCheckX_HdrSqs.js`), 'utf8'),
+    /CartCartCheckXHdrSqs/
+  );
+
+  const resources = await readFile(
+    join(
+      rootPath,
+      'resource/sls_yaml/generatedCode/source/generated-sns-sqs-custom-flows.yml'
+    ),
+    'utf8'
+  );
+  assert.match(
+    resources,
+    new RegExp(
+      'QueueName: \\$\\{self:custom\\.iz_resourcePrefix\\}CartCartCheckXHdrSqs'
+    )
+  );
+});
+
+test('rejects when statusType triggerCache has triggerFlowTypes empty, null, undefined, or missing', async () => {
   for (const emptyTriggerFlowTypes of [[], null, undefined]) {
     const rootPath = await createTriggerCacheProject(emptyTriggerFlowTypes);
-    await generateCustomFlowApplicationArtifacts(rootPath);
-    await generateResourceArtifacts(rootPath);
-
-    const source = 'app/src/generatedCode/FlowSchemas/Cart/source';
-    await assert.rejects(
-      readFile(join(rootPath, `${source}/CartCheckTriggerFlows_Main.js`))
-    );
     await assert.rejects(
-      readFile(join(rootPath, `${source}/CartCheckTriggerFlows_HdrSqs.js`))
+      generateCustomFlowApplicationArtifacts(rootPath),
+      /FlowSchema validation error.*triggerCache.*requires a non-empty 'triggerFlowTypes' array/
     );
-
-    const flowYaml = await readFile(
-      join(rootPath, 'app/sls_yaml/generatedCode/source/flow-schema.yml'),
-      'utf8'
-    );
-    assert.doesNotMatch(flowYaml, /CartCheckTriggerFlowsHdrSqs/);
   }
 });
 
+test('rejects when statusType storedCache cannot resolve DynamoDB table from objType', async () => {
+  const rootPath = await mkdtemp(
+    join(tmpdir(), 'generate-service-code-v2-stored-cache-err-')
+  );
+  roots.add(rootPath);
+  const schemaRoot = join(rootPath, 'app/src/schemas/FlowSchemas');
+  await mkdir(schemaRoot, { recursive: true });
+  await writeFile(
+    join(schemaRoot, 'CacheFlow.js'),
+    "export default { flowTag: 'cacheFlow', event: ['ownTopic'], statusType: 'storedCache', objType: { objectType: 'missingObj' }, flowSteps: [{ stepName: 'Start' }] };\n"
+  );
+  await assert.rejects(
+    generateCustomFlowApplicationArtifacts(rootPath),
+    /FlowSchema validation error.*storedCache.*cannot resolve DynamoDB tableName/
+  );
+});
+
 test('rejects an EventBridge schedule without a deployable name and rate', () => {
   assert.throws(
     () =>
@@ -565,7 +661,7 @@ export default [
   { ...base, flowTag: 'cache', event: ['ownTopic'], statusType: 'storedCache', objType: { objectType: 'order', serviceTag: 'Current' } },
   { ...base, flowTag: 'mixed', event: ['ownTopic', 'extTopic'] },
   { ...base, flowTag: 'generated', event: ['ownTopic'], generatedCodeConfig: { generatedCodeTag: 'create' } },
-  { ...base, flowTag: 'upload', event: ['s3'] }
+  { ...base, flowTag: 'upload', event: ['s3'], bucketName: 'UploadBucket' }
 ];
 `
   );
@@ -1271,3 +1367,49 @@ test('emits handler and YAML for flow with event generateCode and invocationType
   assert.match(yaml, /GenSyncHdrInv:/);
 });
 
+test('rejects FlowSchema with event storedCache at loader', async () => {
+  const rootPath = await createProject();
+  await writeFile(
+    join(rootPath, 'app/src/schemas/FlowSchemas/BadEvent.js'),
+    `export default {
+  flowTag: 'badEvent',
+  event: ['storedCache'],
+  statusType: 'storedCache',
+  objType: { objectType: 'order' },
+  flowSteps: [{ stepName: 'Start' }]
+};\n`
+  );
+
+  await assert.rejects(
+    () => generateCustomFlowApplicationArtifacts(rootPath),
+    /Flow 'badEvent' event\[0\] 'storedCache' is invalid\. Must be one of/
+  );
+});
+
+test('emits early return cacheMain on cache hit in FlowEndpoint_Main for storedCache', async () => {
+  const rootPath = await createProject();
+  await writeFile(
+    join(rootPath, 'app/src/schemas/FlowSchemas/CacheFlow.js'),
+    `export default {
+  flowTag: 'cacheOrder',
+  event: ['ownTopic'],
+  statusType: 'storedCache',
+  objType: { objectType: 'order', serviceTag: 'Current' },
+  flowSteps: [{ stepName: 'Start' }]
+};\n`
+  );
+
+  await generateCustomFlowApplicationArtifacts(rootPath);
+
+  const mainPath = join(
+    rootPath,
+    'app/src/generatedCode/FlowSchemas/CacheOrder/source/CacheOrder_Main.js'
+  );
+  const mainContent = await readFile(mainPath, 'utf8');
+  assert.match(mainContent, /checkStoredCacheStatus/);
+  assert.match(mainContent, /if \(cacheMainStatus === 'complete'\) \{/);
+  assert.match(mainContent, /return cacheMain;/);
+  await parseAsEsm(mainPath);
+});
+
+