@izara_project/izara-core-generate-service-code 1.0.62 → 1.0.64

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izara_project/izara-core-generate-service-code",
-  "version": "1.0.62",
+  "version": "1.0.64",
   "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/codeGenerators/app/initial_setup/templates/InitialSetup_LambdaRole.ejs

@@ -10,7 +10,7 @@ export function generatedLambdaRole() {
   const externalLambdaRole = [
 <% datas.forEach((data, dataIdx) => { -%>
     {
-      roleName: '<%- data.objectType %>',
+      roleName: '<%- data.objectType.replace(/Role$/, '') %>',
       statement: [
 <% data.additionalResourcePermission.forEach((resourcePermission, resourceIdx) => { -%>
         {

package/src/codeGenerators/app/src/generatedCode/Flow/FlowObjects/EndpointsGenerator.js

@@ -80,7 +80,7 @@ export async function generateEndpointsFlow(allSchemas, options) {
     const beforeLogicalConfigs = generateCode.filter(c => c.codeHookTag === 'beforeLogical');
     if (beforeLogicalConfigs.length > 0) {
       const beforeLogicalTemplateStr = await fs.readFile(
-        path.join(templateDir, 'FlowEndpointBeforeLogical_Main.ejs'),
+        path.join(templateDir, 'step', 'FlowEndpointBeforeLogical_Main.ejs'),
         'utf-8'
       );
       const beforeLogicalFileName = `${upperAction}BeforeLogical_Main`;

package/src/codeGenerators/app/src/generatedCode/Flow/FlowObjects/templates/crud/CreateEndpoint_Main.ejs

@@ -41,9 +41,9 @@ const { TOPIC_NAME_GENERATE_CODE, TOPIC_NAME_GRAPH_HANDLER } = consts;
 const PREFIX = {
   ONE: 'one',
   MANY: 'many',
-  CREATE_OBJECT_ASYNC: 'createObjectAsyncEndpoint',
-  CREATE_OBJECT_ASYNC_COMPLETE: 'createObjectAsyncEndpointComplete',
-  CREATE_OBJECT_EXTERNAL_TOPIC: 'createObjectExternalTopicEndpoint'
+  CREATE_OBJECT_ASYNC: 'CreateAsyncEndpoint',
+  CREATE_OBJECT_ASYNC_COMPLETE: 'CreateAsyncEndpointComplete',
+  CREATE_OBJECT_EXTERNAL_TOPIC: 'CreateExternalTopicEndpoint'
 };
 
 /**
@@ -256,13 +256,13 @@ export async function <%- flowTag %>MainLogical(
 
     // ── Create awaiting multiple steps ────────────────────────────────────────
     _izContext.logger.debug('not api will create awaitingStep');
-    await asyncFlowSharedLib.createAwaitingMultipleStepsWithAdditionalAttributes(
+    await asyncFlowSharedLib.createAwaitingMultipleSteps(
       _izContext,
-      allAwaitingStepsId,
       asyncFlowSharedLib.createPendingStepId(
         _izContext.uniqueRequestId,
         PREFIX.CREATE_OBJECT_ASYNC_COMPLETE
-      )
+      ),
+      allAwaitingStepsId,
     );
 
     // ── Process graph objects ─────────────────────────────────────────────────

package/src/codeGenerators/app/src/generatedCode/Flow/{FlowSchemas → FlowObjects}/templates/step/FlowEndpointComplete_Main.ejs

@@ -230,67 +230,77 @@ export default async function <%- functionName %>(
     );
     _izContext.logger.debug('awaitingStepId:', awaitingStepId);
 
-    const recordAwaitingSteps = await dynamodbSharedLib.query(
+    const recordAwaitingStep = await asyncFlowSharedLib.findPendingStepAwaitingMultipleSteps(
       _izContext,
-      await dynamodbSharedLib.tableName(_izContext, 'AwaitingMultipleSteps'),
-      { awaitingStepId },
+      awaitingStepId
     );
-    _izContext.logger.debug('record awaitingSteps::', recordAwaitingSteps);
-
-    await Promise.all(
-      recordAwaitingSteps.Items.map(async (recordAwaitingStep) => {
-        if (
-          await asyncFlowSharedLib.checkAllAwaitingStepsFinished(
-            _izContext,
-            recordAwaitingStep.pendingStepId,
-            awaitingStepId,
-            errorsFound,
-          )
-        ) {
-          _izContext.logger.debug('finish all awaitingStep');
-
-          await Promise.all(
-            recordAwaitingStep.listOfRecords.map(async (listOfRecords) => {
-              if (status ===  'complete') {
-              Object.entries(listOfRecords).map(async ([_, record]) => {
-                await dynamodbSharedLib.putItem(
-                  _izContext,
-                  dynamodbSharedLib.tableName(_izContext,
-                    record.tableName,
-                    record.serviceTag
-                  ),
-                  {
-                    ...record.objInstanceFull.identifiers,
-                    ...record.objInstanceFull.fields
-                  }
-                );
-              })
-            }
-            }))
-
-          const messageObject = _buildMessageObject(
-            returnValue,
-            existsNode,
-            status,
-            errorsFound,
-          );
-
-          //(<beforeSendMessage>)
-          //(</beforeSendMessage>)
-
-          await _sendSnsMessage(_izContext, passBackProperties, messageObject);
-
-          //(<afterSendMessage>)
-          //(</afterSendMessage>)
-        }
-
-        await asyncFlowSharedLib.removeAwaitingMultipleStep(
-          _izContext,
-          awaitingStepId,
-          recordAwaitingStep.pendingStepId,
-          errorsFound,
-        );
-      }),
+    _izContext.logger.debug('recordAwaitingStep:', recordAwaitingStep);
+
+    const {
+      isComplete,
+      collectedAttributes,
+      collectedErrors,
+      returnValues: _rvs,
+      additionalAttributes
+    } = await asyncFlowSharedLib.checkAllAwaitingStepsFinishedWithReturnParams(
+      _izContext,
+      recordAwaitingStep.pendingStepId,
+      awaitingStepId,
+      errorsFound,
+    );
+
+    _izContext.logger.debug('checkAllAwaitingStepsFinishedWithReturnParams:', {
+      isComplete,
+      collectedAttributes,
+      collectedErrors,
+      returnValues: _rvs,
+      additionalAttributes
+    });
+
+    if (isComplete) {
+      _izContext.logger.debug('finish all awaitingStep');
+
+      await Promise.all(
+        (recordAwaitingStep.listOfRecords ?? []).map(async (listOfRecords) => {
+          if (status === 'complete') {
+            Object.entries(listOfRecords).map(async ([_, record]) => {
+              await dynamodbSharedLib.putItem(
+                _izContext,
+                dynamodbSharedLib.tableName(_izContext,
+                  record.tableName,
+                  record.serviceTag
+                ),
+                {
+                  ...record.objInstanceFull.identifiers,
+                  ...record.objInstanceFull.fields
+                }
+              );
+            });
+          }
+        })
+      );
+
+      const messageObject = _buildMessageObject(
+        returnValue,
+        existsNode,
+        status,
+        errorsFound,
+      );
+
+      //(<beforeSendMessage>)
+      //(</beforeSendMessage>)
+
+      await _sendSnsMessage(_izContext, passBackProperties, messageObject);
+
+      //(<afterSendMessage>)
+      //(</afterSendMessage>)
+    }
+
+    await asyncFlowSharedLib.removeAwaitingMultipleStep(
+      _izContext,
+      awaitingStepId,
+      recordAwaitingStep.pendingStepId,
+      errorsFound,
     );
 
     //(<beforeReturn>)

package/src/codeGenerators/app/src/generatedCode/Flow/FlowRelationships/templates/relationship/ProcessChangeRelationship_Main.ejs

@@ -171,8 +171,8 @@ export default async function <%- functionName %> (
       const matchToFrom = fromServiceTag === secondServiceTag && fromObjectType === secondObjectType &&
         toServiceTag === firstServiceTag && toObjType === firstObjectType;
 
-      if ((newRelationshipSchema.relationshipDirection === "from" && matchFromTo) ||
-        (newRelationshipSchema.relationshipDirection === "to" && matchToFrom)) {
+      if ((oldRelTypeAndDirection.relationshipDirection === "from" && matchFromTo) ||
+        (oldRelTypeAndDirection.relationshipDirection === "to" && matchToFrom)) {
         checkCorrectLink = true
         break;
       }

package/src/codeGenerators/app/src/generatedCode/Flow/_shared/handlers/FlowHandler_HdrDsq.ejs

@@ -94,11 +94,19 @@ export const main = middleware.wrap(async (event, context) => {
 
         // add argument (to invoke lambda) to passOnProperties[]
         passOnProperties.push(record.body.Message);
+<% if (functionName.endsWith('Complete')) { %>
+        passOnProperties.push(
+          callingFlowSharedLib.addPassBackPropertiesToPassOnProperties(
+            record.body.Message
+          )
+        );
+<% } else { %>
         passOnProperties.push(
           callingFlowSharedLib.addCallingFlowToPassOnProperties(
             record.body.Message
           )
         );
+<% } %>
         //(<additionalParams>)
         //(</additionalParams>)
         record._izContext.logger.debug(

package/src/codeGenerators/app/src/generatedCode/Flow/_shared/handlers/FlowHandler_HdrSqs.ejs

@@ -76,11 +76,19 @@ export const main = middleware.wrap(async (event, context) => {
 
         // add argument (to invoke lambda) to passOnProperties[]
         passOnProperties.push(record.body.Message);
+<% if (functionName.endsWith('Complete')) { %>
+        passOnProperties.push(
+          callingFlowSharedLib.addPassBackPropertiesToPassOnProperties(
+            record.body.Message
+          )
+        );
+<% } else { %>
         passOnProperties.push(
           callingFlowSharedLib.addCallingFlowToPassOnProperties(
             record.body.Message
           )
         );
+<% } %>
         //(<additionalParams>)
         //(</additionalParams>)
         record._izContext.logger.debug(

package/src/codeGenerators/app/src/generatedCode/Flow/_shared/shared/flowMainFunctionBase.js

@@ -143,10 +143,8 @@ export async function generateFlowMainFunction(allSchemas, options) {
     // 2. Generate BeforeLogical Main Logic File if needed (CRUD flows only)
     const beforeLogicalConfigs = generateCode.filter(c => c.codeHookTag === 'beforeLogical');
     if (isCrud && beforeLogicalConfigs.length > 0) {
-      const beforeLogicalTemplateStr = await fs.readFile(
-        path.join(__dirname, '..', '..', 'FlowObjects', 'templates', 'FlowEndpointBeforeLogical_Main.ejs'),
-        'utf-8'
-      );
+      const beforeLogicalTemplatePath = path.join(__dirname, '..', '..', 'FlowObjects', 'templates', 'step', 'FlowEndpointBeforeLogical_Main.ejs');
+      const beforeLogicalTemplateStr = await fs.readFile(beforeLogicalTemplatePath, 'utf-8');
       
       const beforeLogicalFileName = `${upperCaseFlowTag}BeforeLogical_Main`;
       const beforeLogicalContent = ejs.render(beforeLogicalTemplateStr, {

package/src/codeGenerators/app/src/generatedCode/Flow/_shared/shared/flowStepBase.js

@@ -18,7 +18,7 @@ export async function generateFlowSteps(allSchemas, options) {
     // Read templates
     const templates = {
         main: await fs.readFile(path.join(__dirname, '..', '..', 'FlowSchemas', 'templates', 'step', 'FlowStep_Main.ejs'), 'utf-8'),
-        complete: await fs.readFile(path.join(__dirname, '..', '..', 'FlowSchemas', 'templates', 'step', 'FlowEndpointComplete_Main.ejs'), 'utf-8'),
+        complete: await fs.readFile(path.join(__dirname, '..', '..', 'FlowObjects', 'templates', 'step', 'FlowEndpointComplete_Main.ejs'), 'utf-8'),
         sqs: await fs.readFile(path.join(__dirname, '..', 'handlers', 'FlowHandler_HdrSqs.ejs'), 'utf-8'),
         dsq: await fs.readFile(path.join(__dirname, '..', 'handlers', 'FlowHandler_HdrDsq.ejs'), 'utf-8'),
         api: await fs.readFile(path.join(__dirname, '..', 'handlers', 'FlowHandler_HdrApi.ejs'), 'utf-8'),

package/src/codeGenerators/app/src/generatedCode/Flow/_shared/shared/flowValidator.js

@@ -1,3 +1,5 @@
+import { TYPE_MAP } from './propertyNormalizer.js';
+
 const ALLOWED_EVENTS = ['ownTopic', 'extTopic', 'lambdaSyncInv', 'lambdaSyncApi', 'eventBridge', 's3', 'dsq'];
 const MAIN_ASYNC_EVENTS = ['ownTopic', 'extTopic', 's3'];
 const RESERVED_SYSTEM_FLOW_TAGS = new Set([
@@ -48,6 +50,105 @@ function validateNamedRefs(flowTag, stepName, refs, defs, label, errors) {
   }
 }
 
+function validateStepPropertyTypes(flowTag, propDefs, label, errors) {
+  if (!propDefs || typeof propDefs !== 'object') return;
+  const ALLOWED_TYPES = Object.keys(TYPE_MAP);
+  for (const [key, def] of Object.entries(propDefs)) {
+    if (!def || typeof def !== 'object') continue;
+    if (!def.type) {
+      errors.push(`Flow '${flowTag}' ${label} '${key}' is missing required field 'type'.`);
+      continue;
+    }
+    if (!ALLOWED_TYPES.includes(def.type)) {
+      errors.push(
+        `Flow '${flowTag}' ${label} '${key}' has unsupported type '${def.type}'. Allowed types are: ${ALLOWED_TYPES.join(', ')}.`
+      );
+      continue;
+    }
+    // enum: must supply enumValues array
+    if (def.type === 'enum') {
+      if (!Array.isArray(def.enumValues) || def.enumValues.length === 0) {
+        errors.push(
+          `Flow '${flowTag}' ${label} '${key}' has type 'enum' but is missing a non-empty 'enumValues' array.`
+        );
+      }
+    }
+    // default: must match resolved primitive type
+    // 'mixed' type accepts any value, so skip the type check
+    if (def.default !== undefined && def.type !== 'mixed') {
+      const resolvedPrimitive = TYPE_MAP[def.type];
+      const actualType = Array.isArray(def.default) ? 'array' : typeof def.default;
+      const expectedType = resolvedPrimitive === 'array' ? 'array' : resolvedPrimitive;
+      if (expectedType && actualType !== expectedType) {
+        errors.push(
+          `Flow '${flowTag}' ${label} '${key}' has a 'default' value of type '${actualType}' but expected '${expectedType}' (from schema type '${def.type}').`
+        );
+      }
+    }
+  }
+}
+
+/**
+ * Warn about stepProperties / stepMessageAttributes keys that are declared
+ * but never referenced in any step's properties or messageAttributes arrays.
+ */
+function validateUnusedStepProperties(flowTag, flow, errors) {
+  const stepProps = flow.stepProperties;
+  const stepMsgAttrs = flow.stepMessageAttributes;
+  if (!stepProps && !stepMsgAttrs) return;
+
+  const usedProps = new Set();
+  const usedAttrs = new Set();
+
+  for (const step of Array.isArray(flow.flowSteps) ? flow.flowSteps : []) {
+    for (const ref of Array.isArray(step.properties) ? step.properties : []) {
+      if (typeof ref === 'string') usedProps.add(ref);
+    }
+    for (const ref of Array.isArray(step.messageAttributes) ? step.messageAttributes : []) {
+      if (typeof ref === 'string') usedAttrs.add(ref);
+    }
+  }
+
+  if (stepProps && typeof stepProps === 'object') {
+    for (const key of Object.keys(stepProps)) {
+      if (!usedProps.has(key)) {
+        errors.push(
+          `Flow '${flowTag}' stepProperties key '${key}' is declared but never referenced in any step's 'properties'.`
+        );
+      }
+    }
+  }
+
+  if (stepMsgAttrs && typeof stepMsgAttrs === 'object') {
+    for (const key of Object.keys(stepMsgAttrs)) {
+      if (!usedAttrs.has(key)) {
+        errors.push(
+          `Flow '${flowTag}' stepMessageAttributes key '${key}' is declared but never referenced in any step's 'messageAttributes'.`
+        );
+      }
+    }
+  }
+}
+
+/**
+ * Detect keys that appear in both stepProperties and stepMessageAttributes
+ * to prevent ambiguous naming.
+ */
+function validateDuplicateStepPropertyKeys(flowTag, flow, errors) {
+  const stepProps = flow.stepProperties;
+  const stepMsgAttrs = flow.stepMessageAttributes;
+  if (!stepProps || !stepMsgAttrs) return;
+
+  const propKeys = new Set(Object.keys(stepProps));
+  for (const key of Object.keys(stepMsgAttrs)) {
+    if (propKeys.has(key)) {
+      errors.push(
+        `Flow '${flowTag}' key '${key}' is declared in both 'stepProperties' and 'stepMessageAttributes'. Keys must be unique across both groups.`
+      );
+    }
+  }
+}
+
 export function validateFlowsForGeneration(flows) {
   const errors = [];
   const seenCustomFlowTags = new Set();
@@ -112,6 +213,11 @@ export function validateFlowsForGeneration(flows) {
       validateNamedRefs(flowTag, stepName, step.messageAttributes, flow.stepMessageAttributes, 'messageAttributes', errors);
     }
 
+    validateStepPropertyTypes(flowTag, flow.stepProperties, 'stepProperties', errors);
+    validateStepPropertyTypes(flowTag, flow.stepMessageAttributes, 'stepMessageAttributes', errors);
+    validateDuplicateStepPropertyKeys(flowTag, flow, errors);
+    validateUnusedStepProperties(flowTag, flow, errors);
+
     // ponytail: relaxed anyStepHasPlugInHooks requirement 
     // since unified entry points (step 0) can now handle plugins directly without start.
 

package/src/codeGenerators/app/src/generatedCode/Flow/_shared/shared/propertyNormalizer.js

@@ -1,20 +1,15 @@
-const TYPE_MAP = {
-    string: 'string', number: 'number', integer: 'number',
-    currency: 'string', currencyValue: 'number', numeric: 'number',
-    float: 'number', special: 'string', object: 'object',
-    boolean: 'boolean', array: 'array', arrayMixed: 'array',
-    arrayObject: 'array', arrayNumeric: 'array', arrayString: 'array',
-    timestamp: 'number'
-};
+import { consts } from '@izara_project/izara-shared-service-schemas';
+
+export const TYPE_MAP = consts.FIELDNAME_TYPE_MAPPING;
 
 export function normalizePropertyType(p, lookupSource) {
     let prop = typeof p === 'string'
         ? ((lookupSource && lookupSource[p]) ? lookupSource[p] : { propertyName: p, type: 'string' })
         : p;
-    
+
     if (prop && prop.type) {
         prop = { ...prop, type: TYPE_MAP[prop.type] || prop.type };
     }
-    
+
     return prop;
 }

package/src/codeGenerators/resource/sls_yaml/FlowOutGenerator.js

@@ -44,6 +44,7 @@ export async function generateFlowOut(allSchemas, options) {
     'Create',
     'Update',
     'Delete',
+    'Get',
     'CreateRelationship',
     'UpdateRelationship',
     'DeleteRelationship',

package/src/generate.js

@@ -93,7 +93,7 @@ async function generate(rootPath, options = {}) {
 
 function patchFlowStepsValidationSchema() {
   const flowStepsSchema = basicValidatorSchema.basicFlowSchema?.properties?.flowSteps;
-  if (!flowStepsSchema || flowStepsSchema.oneOf) {
+  if (!flowStepsSchema || flowStepsSchema.oneOf || !flowStepsSchema.items) {
     return;
   }
 

package/test_schema.js

@@ -0,0 +1,2 @@
+import { basicValidatorSchema } from '@izara_project/izara-shared-service-schemas';
+console.log(JSON.stringify(basicValidatorSchema.basicFlowSchema?.properties?.flowSteps, null, 2));