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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izara_project/izara-core-generate-service-code",
-  "version": "1.0.63",
+  "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/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;
 }