@izara_project/izara-core-generate-service-code 1.0.92 → 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/error/emitErrorSchemas.js

@@ -0,0 +1,73 @@
+import { readFile } from 'node:fs/promises';
+import ejsLib from 'ejs';
+
+const TEMPLATE_URL = new URL('./templates/', import.meta.url);
+export const ERROR_SCHEMA_PATH =
+  'app/src/schemas/ErrorSchemas/generateCode/errorSchema.js';
+
+export function errorSchemaManagedPaths(errors = []) {
+  if (!errors || errors.length === 0) {
+    return [];
+  }
+  return [ERROR_SCHEMA_PATH];
+}
+
+/**
+ * Emits errorSchema.js artifact based on loaded ErrorSchemas
+ *
+ * @param {Object} params
+ * @param {Object} params.project
+ * @param {Array} [params.errors=[]]
+ * @param {Array} [params.objectGraphServiceTags=[]]
+ * @returns {Promise<Array<{path: string, content: string}>>}
+ */
+export async function emitErrorSchemas({
+  project = {},
+  errors = [],
+  objectGraphServiceTags = []
+} = {}) {
+  const safeErrors = Array.isArray(errors) ? errors : [];
+  if (safeErrors.length === 0) {
+    return [];
+  }
+
+  const defaultGraphServiceTag =
+    objectGraphServiceTags[0] || 'GraphHandler';
+  const defaultServiceTag = project?.serviceTag || '';
+
+  const errorTypes = {};
+  for (const item of safeErrors) {
+    if (!item || typeof item !== 'object' || !item.errorTag) {
+      continue;
+    }
+    const errorTag = item.errorTag;
+    const serviceTag = item.serviceTag || defaultServiceTag;
+    errorTypes[errorTag] = {
+      errorTag,
+      serviceTag
+    };
+  }
+
+  const sortedKeys = Object.keys(errorTypes).sort();
+  if (sortedKeys.length === 0) {
+    return [];
+  }
+
+  const sortedErrorTypes = {};
+  for (const key of sortedKeys) {
+    sortedErrorTypes[key] = errorTypes[key];
+  }
+
+  const templatePath = new URL('errorSchema.ejs', TEMPLATE_URL);
+  const template = await readFile(templatePath, 'utf8');
+  const content = ejsLib.render(template, {
+    errorTypes: sortedErrorTypes
+  });
+
+  return [
+    {
+      path: ERROR_SCHEMA_PATH,
+      content
+    }
+  ];
+}

package/src/emit/error/templates/errorSchema.ejs

@@ -0,0 +1,8 @@
+export const ERROR_TYPES = {
+<% Object.keys(errorTypes).forEach((key, index, arr) => { -%>
+  <%- key %>: {
+    errorTag: '<%- errorTypes[key].errorTag %>',
+    serviceTag: '<%- errorTypes[key].serviceTag %>'
+  }<%= index < arr.length - 1 ? ',' : '' %>
+<% }); -%>
+};

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/src/generate.js

@@ -61,6 +61,10 @@ import {
   attributeTreeObjectSchemaManagedPaths,
   attributeTreeRelationshipSchemaManagedPaths
 } from './emit/attributeTree/emitAttributeTreeSchemas.js';
+import {
+  emitErrorSchemas,
+  errorSchemaManagedPaths
+} from './emit/error/emitErrorSchemas.js';
 
 export async function generate(rootPath, options = {}) {
   const startedAt = Date.now();
@@ -70,11 +74,18 @@ export async function generate(rootPath, options = {}) {
     const schemaLoadOptions = {
       skipValidation: options.skipValidation
     };
-    const [rawObjects, relationships, flows, notifications] = await Promise.all([
+    const [
+      rawObjects,
+      relationships,
+      flows,
+      notifications,
+      errors
+    ] = await Promise.all([
       loadLocalSchemaDirectory(project, 'ObjectSchemas', schemaLoadOptions),
       loadLocalSchemaDirectory(project, 'RelationshipSchemas', schemaLoadOptions),
       loadLocalSchemaDirectory(project, 'FlowSchemas', schemaLoadOptions),
-      loadLocalSchemaDirectory(project, 'NotificationSchemas', schemaLoadOptions)
+      loadLocalSchemaDirectory(project, 'NotificationSchemas', schemaLoadOptions),
+      loadLocalSchemaDirectory(project, 'ErrorSchemas', schemaLoadOptions)
     ]);
     const schemaBucketName =
       options.schemaBucketName || process.env.iz_serviceSchemaBucketName;
@@ -93,14 +104,24 @@ export async function generate(rootPath, options = {}) {
     console.log(
       `[DEBUG] [Generate] STATUS=SCHEMAS_LOADED | ` +
       `objects=${objects.length} ` +
-      `relationships=${relationships.length} flows=${flows.length}`
+      `relationships=${relationships.length} flows=${flows.length} ` +
+      `notifications=${notifications.length} ` +
+      `errors=${errors.length}`
     );
+    for (const objectSchema of objects) {
+      const objectType = objectSchema.objectType || 'unknown';
+      console.log(
+        `[DEBUG] [Generate] OBJECT_SCHEMA | objectType=${objectType}\n` +
+        JSON.stringify(objectSchema, null, 2)
+      );
+    }
     const groups = await _emitGroups({
       project,
       objects,
       relationships,
       flows,
       notifications,
+      errors,
       objectGraphServiceTags,
       relationshipGraphServiceTags,
       logger: options.logger
@@ -149,6 +170,7 @@ async function _emitGroups({
   relationships,
   flows,
   notifications,
+  errors,
   objectGraphServiceTags,
   relationshipGraphServiceTags,
   logger
@@ -161,7 +183,8 @@ async function _emitGroups({
     findData,
     resource,
     coreFunction,
-    systemText
+    systemText,
+    errorSchemas
   ] = await Promise.all([
     emitCrudApplicationArtifacts({
       objects,
@@ -196,6 +219,11 @@ async function _emitGroups({
       relationships,
       flows,
       notifications
+    }),
+    emitErrorSchemas({
+      project,
+      errors,
+      objectGraphServiceTags
     })
   ]);
   const custom = await emitCustomFlowApplicationArtifacts(flows, {
@@ -307,6 +335,11 @@ async function _emitGroups({
       scope: 'system-text-schemas',
       managedPaths: systemTextSchemaManagedPaths(),
       artifacts: systemText
+    },
+    {
+      scope: 'error-schemas',
+      managedPaths: errorSchemaManagedPaths(errors),
+      artifacts: errorSchemas
     }
   ];
 }

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);
+});
+
+