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

package/package.json

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

@@ -1,7 +1,7 @@
 import ejsLib from 'ejs';
 import { readFile } from 'node:fs/promises';
 
-import { customFlowNextSteps, flowHasRbac, upperFirst } from '../custom/customFlows.js';
+import { customFlowNextSteps } from '../custom/customFlows.js';
 import { createCrudActionPlans } from '../crud/crudActionPlan.js';
 
 const TEMPLATE_URL = new URL('./templates/', import.meta.url);
@@ -217,29 +217,6 @@ export async function emitCoreFunctionArtifacts({ project, objects = [], relatio
     (objects || []).filter(o => o.belongTo?.serviceTag && o.belongTo.serviceTag !== 'Rbac').map(o => o.belongTo.serviceTag)
   )).sort();
 
-  const customRbacFlows = (flows || []).filter((f) => flowHasRbac(f, objects));
-  const customRbacFlowTags = customRbacFlows.map((f) => f.flowTag);
-  const customRbacFlowsWithTags = customRbacFlows.map((f) => {
-    const roleName = upperFirst(f.flowTag);
-    const matched = objects.find((o) => o.objectType === f.objType?.objectType);
-    const targetServiceTags = [];
-    const belongTo = matched?.belongTo;
-    if (belongTo) {
-      if (Array.isArray(belongTo)) {
-        for (const b of belongTo) {
-          if (b?.serviceTag) targetServiceTags.push(b.serviceTag);
-        }
-      } else if (belongTo.serviceTag) {
-        targetServiceTags.push(belongTo.serviceTag);
-      }
-    }
-    return {
-      roleName,
-      flowTag: f.flowTag,
-      targetServiceTags: Array.from(new Set(targetServiceTags))
-    };
-  });
-
   const crudPlans = createCrudActionPlans(objects);
   const hasQuotaReservation = crudPlans?.Create?.hasQuotaReservation ?? false;
 
@@ -250,8 +227,6 @@ export async function emitCoreFunctionArtifacts({ project, objects = [], relatio
     relationships,
     flows,
     customFlowNextSteps: customFlowNextSteps(flows),
-    customRbacFlowTags,
-    customRbacFlowsWithTags,
     objectGraphServiceTags,
     relationshipGraphServiceTags,
     crud,

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) {
@@ -178,23 +178,6 @@ const tableConfigs = {
       }
     });
   });
-
-  const currentServiceTag = (typeof serviceTag !== 'undefined' && serviceTag) ? serviceTag : ((typeof project !== 'undefined' && project?.serviceTag) ? project.serviceTag : '');
-  const rbacSubs = [];
-
-  if (typeof customRbacFlowTags !== 'undefined' && customRbacFlowTags && customRbacFlowTags.length > 0) {
-    const allRbacTags = Array.from(new Set([
-      'Rbac',
-      currentServiceTag,
-      ...(typeof rbacValidatorServiceTags !== 'undefined' ? rbacValidatorServiceTags : [])
-    ])).filter(Boolean);
-    customRbacFlowTags.forEach(function(flowTag) {
-      const tagUpper = flowTag[0].toUpperCase() + flowTag.slice(1);
-      allRbacTags.forEach(function(tag) {
-        rbacSubs.push({ serviceTag: tag, topicName: 'ValidatorRbac_Out', sqsEndpoint: `${tagUpper}RbacCallbackHdrSqs` });
-      });
-    });
-  }
 -%>
 const snsTopicSubscriptions = [
 <% if (relSubs.length > 0) { -%>
@@ -247,19 +230,6 @@ const snsTopicSubscriptions = [
     sqsEndpoint: '<%= sub.sqsEndpoint %>'
   },
 <% }); -%>
-<% } -%>
-<% if (rbacSubs.length > 0) { -%>
-
-  // ------------------------------------------------------------
-  // RBAC Validator Subscriptions
-  // ------------------------------------------------------------
-<% rbacSubs.forEach(function(sub, idx) { -%>
-  {
-    serviceTag: '<%= sub.serviceTag %>',
-    topicName: '<%= sub.topicName %>',
-    sqsEndpoint: '<%= sub.sqsEndpoint %>'
-  },
-<% }); -%>
 <% } -%>
 
   //(<additionalSubscription>)

package/src/emit/custom/customFlowPaths.js

@@ -4,8 +4,7 @@ import {
   generatedDsqFlows,
   generatedOwnTopicFlows,
   supportedCustomFlows,
-  upperFirst,
-  flowHasRbac
+  upperFirst
 } from './customFlows.js';
 
 export const YAML_PATH = 'app/sls_yaml/generatedCode/source/flow-schema.yml';
@@ -35,12 +34,6 @@ export function ownTopicRootPaths(flow, objects = []) {
     `${source}/${tag}_WbsMain.js`,
     `${source}/${tag}_HdrWbs.js`
   ];
-  if (flowHasRbac(flow, objects)) {
-    paths.push(
-      `${source}/${tag}RbacCallback_Main.js`,
-      `${source}/${tag}RbacCallback_HdrSqs.js`
-    );
-  }
   return paths;
 }
 
@@ -52,12 +45,6 @@ export function flowPaths(flow, objects = []) {
   if (needsProcessMain(flow)) {
     paths.push(`${source}/${process}_Main.js`);
   }
-  if (flowHasRbac(flow, objects)) {
-    paths.push(
-      `${source}/${tag}RbacCallback_Main.js`,
-      `${source}/${tag}RbacCallback_HdrSqs.js`
-    );
-  }
   if (flow.event.includes('extTopic') && !flow.event.includes('ownTopic')) {
     paths.push(`${source}/${process}_HdrSqs.js`);
   }
@@ -116,7 +103,7 @@ export function customFlowApplicationManagedPaths(
   const extSteps = flowExtTopicSteps(flows);
   const dsqSteps = flowDsqSteps(flows);
 
-  return [
+  return Array.from(new Set([
     ...customFlowList.flatMap((flow) => flowPaths(flow, objects)),
     ...generatedRoots.flatMap((flow) => ownTopicRootPaths(flow, objects)),
     ...extSteps.flatMap(({ flowTag, stepName }) => {
@@ -145,5 +132,5 @@ export function customFlowApplicationManagedPaths(
     dsqSteps.length > 0
       ? [YAML_PATH]
       : [])
-  ];
+  ]));
 }

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: ''
           });