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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izara_project/izara-core-generate-service-code",
-  "version": "1.0.93",
+  "version": "1.0.94",
   "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/compile/compileProject.js

@@ -32,7 +32,9 @@ export function compileProject(request = {}) {
         }
       }
     } catch (err) {
-      console.log('Could not read serverless.config.yml', err);
+      throw new Error(
+        `Failed to read or parse configuration at ${configPath}: ${err.message}`
+      );
     }
   }
 

package/src/compile/flowValidator.js

@@ -1,8 +1,67 @@
+export const VALID_EVENT_ENUM = [
+  'eventBridge',
+  'extTopic',
+  'lambdaSyncInv',
+  'lambdaSyncApi',
+  'ownTopic',
+  's3',
+  'dsq',
+  'generateCode'
+];
+
 export function validateFlowSchema(flowSchema) {
   if (!flowSchema || typeof flowSchema !== 'object') {
     throw new TypeError('flowSchema must be an object');
   }
 
+  if (
+    typeof flowSchema.flowTag !== 'string' ||
+    flowSchema.flowTag.trim() === ''
+  ) {
+    throw new Error(
+      'FlowSchema validation error: flowTag is required and must be a non-empty string'
+    );
+  }
+  const flowTag = flowSchema.flowTag;
+
+  if (!Array.isArray(flowSchema.event) || flowSchema.event.length === 0) {
+    throw new Error(
+      `FlowSchema validation error: Flow '${flowTag}' requires a non-empty 'event' array`
+    );
+  }
+
+  for (const [eIdx, eventName] of flowSchema.event.entries()) {
+    if (
+      typeof eventName !== 'string' ||
+      !VALID_EVENT_ENUM.includes(eventName)
+    ) {
+      throw new Error(
+        `FlowSchema validation error: Flow '${flowTag}' event[${eIdx}] '${eventName}' is invalid. Must be one of ${JSON.stringify(VALID_EVENT_ENUM)}`
+      );
+    }
+  }
+
+  if (
+    flowSchema.event.includes('generateCode') &&
+    flowSchema.event.length > 1
+  ) {
+    throw new Error(
+      `FlowSchema validation error: Flow '${flowTag}' with event 'generateCode' must be a standalone event and cannot co-exist with other events`
+    );
+  }
+
+  if (flowSchema.event.includes('s3')) {
+    if (
+      !flowSchema.bucketName ||
+      typeof flowSchema.bucketName !== 'string' ||
+      flowSchema.bucketName.trim() === ''
+    ) {
+      throw new Error(
+        `FlowSchema validation error: Flow '${flowTag}' with event 's3' requires 'bucketName' as a non-empty string`
+      );
+    }
+  }
+
   if (flowSchema.initiateBy !== undefined) {
     const validInitiateBy = [
       'user',
@@ -25,6 +84,110 @@ export function validateFlowSchema(flowSchema) {
     }
   }
 
+  if (flowSchema.statusType !== undefined) {
+    const validStatusType = [
+      'none',
+      'statusField',
+      'storedCache',
+      'triggerCache'
+    ];
+    if (!validStatusType.includes(flowSchema.statusType)) {
+      throw new Error(
+        `FlowSchema validation error: Flow '${flowTag}' statusType must be one of ${JSON.stringify(validStatusType)}, got '${flowSchema.statusType}'`
+      );
+    }
+
+    if (flowSchema.statusType !== 'none') {
+      if (!flowSchema.objType) {
+        throw new Error(
+          `FlowSchema validation error: Flow '${flowTag}' with statusType '${flowSchema.statusType}' requires 'objType'`
+        );
+      }
+
+      if (flowSchema.statusType === 'storedCache') {
+        const objTypeVal =
+          typeof flowSchema.objType === 'string'
+            ? flowSchema.objType
+            : flowSchema.objType?.objectType;
+        if (typeof objTypeVal !== 'string' || objTypeVal.trim() === '') {
+          throw new Error(
+            `FlowSchema validation error: Flow '${flowTag}' with statusType 'storedCache' requires 'objType' to be a non-empty string or object with string 'objectType'`
+          );
+        }
+      }
+
+      if (flowSchema.statusType === 'triggerCache') {
+        if (
+          !Array.isArray(flowSchema.triggerFlowTypes) ||
+          flowSchema.triggerFlowTypes.length === 0
+        ) {
+          throw new Error(
+            `FlowSchema validation error: Flow '${flowTag}' with statusType 'triggerCache' requires a non-empty 'triggerFlowTypes' array`
+          );
+        }
+        for (const [tIdx, item] of flowSchema.triggerFlowTypes.entries()) {
+          if (!item || (typeof item !== 'string' && typeof item !== 'object')) {
+            throw new Error(
+              `FlowSchema validation error: Flow '${flowTag}' triggerFlowTypes[${tIdx}] must be a non-empty string or object`
+            );
+          }
+          if (typeof item === 'string' && item.trim() === '') {
+            throw new Error(
+              `FlowSchema validation error: Flow '${flowTag}' triggerFlowTypes[${tIdx}] must not be an empty string`
+            );
+          }
+        }
+      }
+    }
+  }
+
+  if (
+    flowSchema.event.includes('generateCode') &&
+    !flowSchema.generatedCodeConfig
+  ) {
+    throw new Error(
+      `FlowSchema validation error: Flow '${flowTag}' with event 'generateCode' requires 'generatedCodeConfig'`
+    );
+  }
+
+  if (flowSchema.generatedCodeConfig) {
+    const config = flowSchema.generatedCodeConfig;
+    if (
+      config.invocationType !== undefined &&
+      !['ownTopic', 'lambdaSyncInv'].includes(config.invocationType)
+    ) {
+      throw new Error(
+        `FlowSchema validation error: Flow '${flowTag}' generatedCodeConfig.invocationType '${config.invocationType}' is invalid. Must be 'ownTopic' or 'lambdaSyncInv'`
+      );
+    }
+    const isOwnTopic = flowSchema.event.includes('ownTopic');
+    const isDsq = flowSchema.event.includes('dsq');
+    const isHook = Boolean(
+      config.generateCodeTag ||
+        config.invocationType ||
+        config.objType ||
+        flowSchema.event.includes('generateCode') ||
+        (!isOwnTopic && !isDsq)
+    );
+
+    const hookTag = config.codeHookTag;
+    if (hookTag === 'beforeLogical') {
+      throw new Error(
+        `FlowSchema validation error: Flow '${flowTag}' generatedCodeConfig.codeHookTag is no longer supported`
+      );
+    }
+    if (isHook && !hookTag) {
+      throw new Error(
+        `FlowSchema validation error: Flow '${flowTag}' generatedCodeConfig requires 'codeHookTag' ('before' | 'after'), got '${hookTag}'`
+      );
+    }
+    if (hookTag !== undefined && hookTag !== 'before' && hookTag !== 'after') {
+      throw new Error(
+        `FlowSchema validation error: Flow '${flowTag}' generatedCodeConfig.codeHookTag '${hookTag}' is invalid. Must be 'before' or 'after'`
+      );
+    }
+  }
+
   const steps = flowSchema.flowSteps;
   if (!Array.isArray(steps) || steps.length === 0) {
     throw new Error(
@@ -32,10 +195,7 @@ export function validateFlowSchema(flowSchema) {
     );
   }
 
-  let flowEvents = [];
-  if (Array.isArray(flowSchema.event)) {
-    flowEvents = flowSchema.event;
-  }
+  const flowEvents = flowSchema.event;
   const syncEvents = ['lambdaSyncInv', 'lambdaSyncApi'];
   let hasSyncEvent = false;
   for (const eventName of flowEvents) {
@@ -52,10 +212,6 @@ export function validateFlowSchema(flowSchema) {
   }
 
   if (hasSyncEvent && steps.length > 1) {
-    let flowTag = 'unknown';
-    if (flowSchema.flowTag) {
-      flowTag = flowSchema.flowTag;
-    }
     throw new Error(
       `FlowSchema validation error: Flow '${flowTag}' with synchronous ` +
       `events ('lambdaSyncInv' | 'lambdaSyncApi') must only define a ` +
@@ -110,6 +266,17 @@ export function validateFlowSchema(flowSchema) {
       );
     }
 
+    if (step.stepName.toLowerCase().includes('checktrigger')) {
+      if (
+        !Array.isArray(flowSchema.triggerFlowTypes) ||
+        flowSchema.triggerFlowTypes.length === 0
+      ) {
+        throw new Error(
+          `FlowSchema validation error: Flow '${flowTag}' defines step '${step.stepName}' but requires a non-empty 'triggerFlowTypes' array`
+        );
+      }
+    }
+
     if (Array.isArray(step.nextSteps) && step.nextSteps.length > 0) {
       for (let nIdx = 0; nIdx < step.nextSteps.length; nIdx++) {
         const item = step.nextSteps[nIdx];
@@ -128,9 +295,10 @@ export function validateFlowSchema(flowSchema) {
           );
         }
         if (item.targetType === 'ownTopic') {
+          const ownTopicTarget = item.stepName || item.topic;
           if (
-            typeof item.stepName !== 'string' ||
-            item.stepName.trim() === ''
+            typeof ownTopicTarget !== 'string' ||
+            ownTopicTarget.trim() === ''
           ) {
             throw new Error(
               `FlowSchema validation error: flowSteps[${idx}].nextSteps[${nIdx}] ownTopic target requires non-empty 'stepName'`
@@ -145,10 +313,8 @@ export function validateFlowSchema(flowSchema) {
               `FlowSchema validation error: flowSteps[${idx}].nextSteps[${nIdx}] extTopic target requires non-empty 'serviceTag'`
             );
           }
-          if (
-            typeof item.topicName !== 'string' ||
-            item.topicName.trim() === ''
-          ) {
+          const extTopicName = item.topicName || item.topic;
+          if (typeof extTopicName !== 'string' || extTopicName.trim() === '') {
             throw new Error(
               `FlowSchema validation error: flowSteps[${idx}].nextSteps[${nIdx}] extTopic target requires non-empty 'topicName'`
             );
@@ -203,10 +369,8 @@ export function validateFlowSchema(flowSchema) {
               `FlowSchema validation error: flowSteps[${idx}].previousSteps[${pIdx}] extTopic source requires non-empty 'serviceTag'`
             );
           }
-          if (
-            typeof item.topicName !== 'string' ||
-            item.topicName.trim() === ''
-          ) {
+          const extSourceName = item.topicName || item.topic;
+          if (typeof extSourceName !== 'string' || extSourceName.trim() === '') {
             throw new Error(
               `FlowSchema validation error: flowSteps[${idx}].previousSteps[${pIdx}] extTopic source requires non-empty 'topicName'`
             );

package/src/compile/loadSchemas.js

@@ -206,6 +206,118 @@ export async function loadLocalSchemaDirectory(
 
     if (directoryName === 'FlowSchemas') {
       for (const schema of loadedSchemas) {
+        if (!schema?._sourceFile) {
+          schema._sourceFile = entry.name;
+        }
+        if (
+          !schema?.flowTag ||
+          typeof schema.flowTag !== 'string' ||
+          schema.flowTag.trim() === ''
+        ) {
+          throw new Error(
+            `FlowSchema validation error in ${entry.name}: flowTag is required and must be a non-empty string`
+          );
+        }
+        const flowTag = schema.flowTag;
+
+        if (!Array.isArray(schema.event) || schema.event.length === 0) {
+          throw new Error(
+            `FlowSchema validation error in ${entry.name}: Flow '${flowTag}' requires a non-empty 'event' array`
+          );
+        }
+
+        for (const [eIdx, eventName] of schema.event.entries()) {
+          if (
+            typeof eventName !== 'string' ||
+            !VALID_EVENT_ENUM.includes(eventName)
+          ) {
+            throw new Error(
+              `FlowSchema validation error in ${entry.name}: Flow '${flowTag}' event[${eIdx}] '${eventName}' is invalid. ` +
+                `Must be one of ${JSON.stringify(VALID_EVENT_ENUM)}`
+            );
+          }
+        }
+
+        if (
+          schema.event.includes('generateCode') &&
+          schema.event.length > 1
+        ) {
+          throw new Error(
+            `FlowSchema validation error in ${entry.name}: Flow '${flowTag}' with event 'generateCode' must be a standalone event and cannot co-exist with other events`
+          );
+        }
+
+        if (schema?.statusType !== undefined && schema?.statusType !== 'none') {
+          const validStatusTypes = [
+            'statusField',
+            'storedCache',
+            'triggerCache',
+            'none'
+          ];
+          if (!validStatusTypes.includes(schema.statusType)) {
+            throw new Error(
+              `FlowSchema validation error in ${entry.name}: Flow '${flowTag}' statusType must be one of ${JSON.stringify(validStatusTypes)}, got '${schema.statusType}'`
+            );
+          }
+          if (!schema.objType) {
+            throw new Error(
+              `FlowSchema validation error in ${entry.name}: Flow '${flowTag}' with statusType '${schema.statusType}' requires 'objType'`
+            );
+          }
+          if (schema.statusType === 'storedCache') {
+            const objTypeVal =
+              typeof schema.objType === 'string'
+                ? schema.objType
+                : schema.objType?.objectType;
+            if (typeof objTypeVal !== 'string' || objTypeVal.trim() === '') {
+              throw new Error(
+                `FlowSchema validation error in ${entry.name}: Flow '${flowTag}' with statusType 'storedCache' requires 'objType' to be a non-empty string or object with string 'objectType'`
+              );
+            }
+          }
+          if (schema.statusType === 'triggerCache') {
+            if (
+              !Array.isArray(schema.triggerFlowTypes) ||
+              schema.triggerFlowTypes.length === 0
+            ) {
+              throw new Error(
+                `FlowSchema validation error in ${entry.name}: Flow '${flowTag}' with statusType 'triggerCache' requires a non-empty 'triggerFlowTypes' array`
+              );
+            }
+            for (const [tIdx, item] of schema.triggerFlowTypes.entries()) {
+              if (
+                !item ||
+                (typeof item !== 'string' && typeof item !== 'object')
+              ) {
+                throw new Error(
+                  `FlowSchema validation error in ${entry.name}: Flow '${flowTag}' triggerFlowTypes[${tIdx}] must be a non-empty string or object`
+                );
+              }
+              if (typeof item === 'string' && item.trim() === '') {
+                throw new Error(
+                  `FlowSchema validation error in ${entry.name}: Flow '${flowTag}' triggerFlowTypes[${tIdx}] must not be an empty string`
+                );
+              }
+            }
+          }
+        }
+        if (Array.isArray(schema?.flowSteps)) {
+          for (const step of schema.flowSteps) {
+            if (
+              typeof step?.stepName === 'string' &&
+              step.stepName.toLowerCase().includes('checktrigger')
+            ) {
+              if (
+                !Array.isArray(schema.triggerFlowTypes) ||
+                schema.triggerFlowTypes.length === 0
+              ) {
+                throw new Error(
+                  `FlowSchema validation error in ${entry.name}: Flow '${flowTag}' defines step '${step.stepName}' but requires a non-empty 'triggerFlowTypes' array`
+                );
+              }
+            }
+          }
+        }
         if (
           Array.isArray(schema?.event) &&
           schema.event.includes('generateCode') &&
@@ -234,19 +346,37 @@ export async function loadLocalSchemaDirectory(
             );
           }
         }
-        if (
-          Object.prototype.hasOwnProperty.call(
-            schema?.generatedCodeConfig ?? {},
-            'codeHookTag'
-          )
-        ) {
-          const hookTag = schema.generatedCodeConfig.codeHookTag;
+        if (schema?.generatedCodeConfig) {
+          const config = schema.generatedCodeConfig;
+          const isOwnTopic =
+            Array.isArray(schema.event) && schema.event.includes('ownTopic');
+          const isDsq =
+            Array.isArray(schema.event) && schema.event.includes('dsq');
+          const isHook = Boolean(
+            config.generateCodeTag ||
+              config.invocationType ||
+              config.objType ||
+              (Array.isArray(schema.event) &&
+                schema.event.includes('generateCode')) ||
+              (!isOwnTopic && !isDsq)
+          );
+
+          const hookTag = config.codeHookTag;
           if (hookTag === 'beforeLogical') {
             throw new Error(
               `Unsupported FlowHook configuration in ${entry.name}: generatedCodeConfig.codeHookTag is no longer supported`
             );
           }
-          if (hookTag !== 'before' && hookTag !== 'after') {
+          if (isHook && !hookTag) {
+            throw new Error(
+              `Unsupported FlowHook configuration in ${entry.name}: Flow '${flowTag}' with generatedCodeConfig requires 'codeHookTag' ('before' or 'after')`
+            );
+          }
+          if (
+            hookTag !== undefined &&
+            hookTag !== 'before' &&
+            hookTag !== 'after'
+          ) {
             throw new Error(
               `Unsupported FlowHook configuration in ${entry.name}: generatedCodeConfig.codeHookTag '${hookTag}' is invalid. Must be 'before' or 'after'`
             );
@@ -718,6 +848,11 @@ function _isTestEnvironment() {
     process.env.NODE_ENV === 'test' ||
     process.env.npm_lifecycle_event === 'test' ||
     Boolean(process.execArgv?.includes('--test')) ||
-    Boolean(process.argv?.includes('--test'))
+    Boolean(process.argv?.includes('--test')) ||
+    Boolean(
+      process.argv?.some(
+        (arg) => arg.includes('.test.') || arg.includes('test/')
+      )
+    )
   );
 }

package/src/emit/coreFunction/templates/InitialSetupConfig.ejs

@@ -160,7 +160,7 @@ const tableConfigs = {
     (flow?.flowSteps || []).forEach(function(step) {
       if (Array.isArray(step?.previousSteps)) {
         const stepName = step?.stepName ? step.stepName[0].toUpperCase() + step.stepName.slice(1) : '';
-        const functionName = stepName.startsWith(flowTag) ? stepName : `${flowTag}${stepName}`;
+        const functionName = `${flowTag}${stepName}`;
         const queueName = `${functionName}HdrSqs`;
         step.previousSteps.forEach(function(prev) {
           if (prev && prev.sourceType === 'extTopic' && prev.serviceTag && prev.topicName) {

package/src/emit/custom/customFlowS3.js

@@ -88,13 +88,18 @@ export async function emitS3Flow(flow, source, handlerRoot) {
             filterPatternFunctionName
           });
         } else if (type === 's3') {
-          let bucketName = '';
-          if (flow.bucketName) {
-            bucketName = flow.bucketName;
+          if (
+            !flow.bucketName ||
+            typeof flow.bucketName !== 'string' ||
+            flow.bucketName.trim() === ''
+          ) {
+            throw new Error(
+              `FlowSchema validation error: Flow '${flow.flowTag}' with event 's3' requires 'bucketName' as a non-empty string`
+            );
           }
           functionYaml = renderS3FunctionYaml({
             ...descriptor,
-            bucketName,
+            bucketName: flow.bucketName,
             flowTag: flow.flowTag,
             flowStepName: ''
           });

package/src/emit/custom/customFlowSteps.js

@@ -13,10 +13,7 @@ import {
 export async function emitExtTopicStep({ flow, step, flowTag, stepName }) {
   const source = `app/src/generatedCode/FlowSchemas/${flowTag}/source`;
   const handlerRoot = `src/generatedCode/FlowSchemas/${flowTag}/source`;
-  let functionName = `${flowTag}${stepName}`;
-  if (stepName.startsWith(flowTag)) {
-    functionName = stepName;
-  }
+  const functionName = `${flowTag}${stepName}`;
   const mainFileName = `${functionName}_Main`;
   const startConfig = stepConfig(flow, step);
 
@@ -352,8 +349,12 @@ export function storedCacheTableName(flow, objects) {
   if (flow.statusType !== 'storedCache') {
     return null;
   }
+  const targetObjectType =
+    typeof flow.objType === 'string'
+      ? flow.objType
+      : flow.objType?.objectType;
   const candidates = objects.filter(
-    (object) => object.objectType === flow.objType?.objectType
+    (object) => object.objectType === targetObjectType
   );
   let object;
   if (flow.objType?.serviceTag) {
@@ -373,7 +374,14 @@ export function storedCacheTableName(flow, objects) {
   if (targetResource?.tableName) {
     return targetResource.tableName;
   }
-  return null;
+  const flowTag = flow.flowTag || 'unknown';
+  const targetObj = JSON.stringify(flow.objType);
+  console.error(
+    `[ERROR] [FlowSchema Validation] Flow '${flowTag}' has statusType 'storedCache' but cannot resolve DynamoDB tableName from objType ${targetObj}`
+  );
+  throw new Error(
+    `FlowSchema validation error: Flow '${flowTag}' has statusType 'storedCache' but cannot resolve DynamoDB tableName from objType ${targetObj}. Ensure the ObjectSchema exists and defines a DynamoDB storage resource with tableName.`
+  );
 }
 
 export async function renderStepMain(functionName, startConfig = null) {

package/src/emit/custom/customFlows.js

@@ -14,11 +14,20 @@ export function supportedCustomFlows(flows) {
     throw new TypeError('flows must be an array');
   }
   return flows.filter((flow) => {
-    if (typeof flow?.flowTag !== 'string' || flow.flowTag === '') {
-      return false;
+    if (typeof flow?.flowTag !== 'string' || flow.flowTag.trim() === '') {
+      throw new Error(
+        'FlowSchema validation error: flowTag is required and must be a non-empty string'
+      );
     }
-    if (!Array.isArray(flow.event)) {
-      return false;
+    if (!Array.isArray(flow.event) || flow.event.length === 0) {
+      throw new Error(
+        `FlowSchema validation error: Flow '${flow.flowTag}' requires a non-empty 'event' array`
+      );
+    }
+    if (flow.event.includes('generateCode') && flow.event.length > 1) {
+      throw new Error(
+        `FlowSchema validation error: Flow '${flow.flowTag}' with event 'generateCode' must be a standalone event and cannot co-exist with other events`
+      );
     }
     const hasSupportedEvent = flow.event.some((e) => SUPPORTED_EVENTS.has(e));
     if (!hasSupportedEvent) {
@@ -28,9 +37,14 @@ export function supportedCustomFlows(flows) {
       if (flowHasOwnTopic(flow)) {
         return false;
       }
-      if (!flow.generatedCodeConfig.codeHookTag) {
+      if (flow.event.includes('dsq')) {
         return false;
       }
+      if (!flow.generatedCodeConfig.codeHookTag) {
+        throw new Error(
+          `FlowSchema validation error: Flow '${flow.flowTag}' has generatedCodeConfig without ownTopic, which requires 'codeHookTag' ('before' | 'after')`
+        );
+      }
     }
     return true;
   });
@@ -67,6 +81,11 @@ export function flowExtTopicSteps(flows) {
     }
     const hasTriggerFlowTypes =
       Array.isArray(flow.triggerFlowTypes) && flow.triggerFlowTypes.length > 0;
+    if (flow.statusType === 'triggerCache' && !hasTriggerFlowTypes) {
+      throw new Error(
+        `FlowSchema validation error: Flow '${flow.flowTag}' has statusType 'triggerCache' but requires a non-empty 'triggerFlowTypes' array`
+      );
+    }
     const steps = flow.flowSteps ?? [];
     const hasCheckStep = steps.some(
       (step) =>
@@ -87,7 +106,9 @@ export function flowExtTopicSteps(flows) {
       }
       const isCheckStep = step.stepName.toLowerCase().includes('checktrigger');
       if (isCheckStep && !hasTriggerFlowTypes) {
-        return [];
+        throw new Error(
+          `FlowSchema validation error: Flow '${flow.flowTag}' defines step '${step.stepName}' but requires a non-empty 'triggerFlowTypes' array`
+        );
       }
       return [
         {