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

package/src/emit/rbac/templates/RbacMutation_Main.ejs

@@ -0,0 +1,22 @@
+<% const fieldList = fields.join(', '); -%>
+import dynamodbSharedLib from '@izara_project/izara-core-library-dynamodb';
+import snsSharedLib from '@izara_project/izara-core-library-sns';
+import { sns } from '@izara_project/izara-core-library-external-request';
+
+export default async function Process<%- flowTag %>(_izContext, requestParams) {
+  try {
+    const { <%- fieldList %> } = requestParams;
+    await dynamodbSharedLib.<%- method %>(
+      _izContext,
+      dynamodbSharedLib.tableName(_izContext, '<%- tableName %>'),
+      { <%- fieldList %> }
+    );
+    await sns.publishMessage(_izContext, {
+      message: { returnResult: { <%- fieldList %> } },
+      TopicArn: snsSharedLib.snsTopicArnByFlowSchema(_izContext, '<%- flowTag %>_Out')
+    });
+  } catch (error) {
+    _izContext.logger.error('[Rbac:Process<%- flowTag %>] error:', error);
+    throw error;
+  }
+}

package/src/emit/rbac/templates/UserRbacFlow_HdrInv.ejs

@@ -0,0 +1,10 @@
+import { middlewareHandler as middleware } from '@izara_project/izara-middleware';
+import callingFlowSharedLib from '@izara_project/izara-core-library-calling-flow';
+import Process<%- flowTag %> from './Process<%- flowTag %>_Main.js';
+
+middleware.setValidatorSchema({});
+export const main = middleware.wrap(async event => Process<%- flowTag %>(
+  event._izContext,
+  event,
+  callingFlowSharedLib.addCallingFlowToPassOnProperties(event)
+));

package/src/emit/rbac/templates/UserRbacFlow_Main.ejs

@@ -0,0 +1,44 @@
+import dynamodbSharedLib from '@izara_project/izara-core-library-dynamodb';
+import { coreConsts } from '@izara_project/izara-core-library-core';
+
+export default async function Process<%- flowTag %>(_izContext, requestParams) {
+  try {
+    const userId = _izContext.correlationIds.get(coreConsts.BASE_USER_ID);
+    const targetId = _izContext.correlationIds.get(coreConsts.TARGET_ID);
+    if (!userId && !targetId) throw new Error('Missing required request parameters: userId or targetId');
+    const { flowTypeConcat, inputParameterGroups } = requestParams;
+    if (!flowTypeConcat) throw new Error('Missing flowTypeConcat in requestParams');
+    const userRoles = (await dynamodbSharedLib.query(
+      _izContext,
+      dynamodbSharedLib.tableName(_izContext, 'UserRoles'),
+      { userId }
+    )).Items || [];
+    const targetRoles = userRoles.filter(role => role.roleIdKey?.startsWith(targetId + '_'));
+    for (const role of targetRoles) {
+      const permission = await dynamodbSharedLib.getItem(
+        _izContext,
+        dynamodbSharedLib.tableName(_izContext, 'RolePermissions'),
+        { roleIdKey: role.roleIdKey, flowTypeConcat }
+      );
+      if (permission?.permission === true && matchesParameterGroups(permission.parameterGroups, inputParameterGroups)) {
+        return { permission: true, roleIdKey: permission.roleIdKey };
+      }
+    }
+    return { permission: false, roleIdKey: '' };
+  } catch (error) {
+    _izContext.logger.error('error Process<%- flowTag %>:', error);
+    throw error;
+  }
+}
+
+function matchesParameterGroups(groups, input) {
+  if (!groups || typeof groups !== 'object' || Array.isArray(groups) || Object.keys(groups).length === 0) return true;
+  return Object.values(groups).some(group => Array.isArray(group) && group.every(check => {
+    let value = input || {};
+    for (const name of check.parameterNames || []) {
+      if (!value || typeof value !== 'object' || !(name in value)) return false;
+      value = value[name];
+    }
+    return Array.isArray(check.parameterValues) && check.parameterValues.includes(value);
+  }));
+}

package/src/emit/rbac/templates/UserRoleMutation_Main.ejs

@@ -0,0 +1,33 @@
+<%
+const itemType = operation === 'Put' ? 'Item' : 'Key';
+const roleUsersKey = operation === 'Put' ? 'userId, roleIdKey' : 'roleIdKey, userId';
+-%>import dynamodbSharedLib from '@izara_project/izara-core-library-dynamodb';
+import snsSharedLib from '@izara_project/izara-core-library-sns';
+import { sns } from '@izara_project/izara-core-library-external-request';
+
+export default async function Process<%- flowTag %>(_izContext, requestParams) {
+  try {
+    const { roleIdKey, userId } = requestParams;
+    await dynamodbSharedLib.transactWriteItems(_izContext, [
+      {
+        <%- operation %>: {
+          TableName: dynamodbSharedLib.tableName(_izContext, 'RoleUsers'),
+          <%- itemType %>: { <%- roleUsersKey %> }
+        }
+      },
+      {
+        <%- operation %>: {
+          TableName: dynamodbSharedLib.tableName(_izContext, 'UserRoles'),
+          <%- itemType %>: { userId, roleIdKey }
+        }
+      }
+    ]);
+    await sns.publishMessage(_izContext, {
+      message: { returnResult: { userId, roleIdKey } },
+      TopicArn: snsSharedLib.snsTopicArnByFlowSchema(_izContext, '<%- flowTag %>_Out')
+    });
+  } catch (error) {
+    _izContext.logger.error('[Rbac:Process<%- flowTag %>] error:', error);
+    throw error;
+  }
+}

package/src/emit/relationship/dynamicRelationshipFlowSchemaTemplate.js

@@ -0,0 +1,11 @@
+export function renderDynamicRelationshipFlowSchema(action, flow) {
+  return [
+    '/**',
+    ' * GENERATED DYNAMIC RELATIONSHIP FLOW SCHEMA',
+    ` * Action: ${action}`,
+    ' * Description: Handles dynamic relationship actions for all allowed RelationshipTypes via SQS/DSQ',
+    ' */',
+    `export default ${JSON.stringify(flow, null, 2)};`,
+    ''
+  ].join('\n');
+}

package/src/emit/relationship/emitDynamicRelationshipFlowSchemas.js

@@ -0,0 +1,66 @@
+import { renderDynamicRelationshipFlowSchema } from './dynamicRelationshipFlowSchemaTemplate.js';
+
+const ACTIONS = [
+  'CreateRelationship',
+  'UpdateRelationship',
+  'DeleteRelationship',
+  'GetRelationship',
+  'ChangeRelationship',
+  'MoveRelationship'
+];
+const MESSAGE_ATTRIBUTES = ['userId', 'correlationId'];
+
+export const dynamicRelationshipFlowSchemaPaths = ACTIONS.map(
+  action => `app/src/schemas/FlowSchemas/generateCode/${action}.js`
+);
+
+export function emitDynamicRelationshipFlowSchemas() {
+  // Keep legacy compatibility: relationship flow endpoints exist even before a relationship is declared.
+  return ACTIONS.map((action, index) => ({
+    path: dynamicRelationshipFlowSchemaPaths[index],
+    content: renderDynamicRelationshipFlowSchema(action, createDynamicRelationshipFlow(action))
+  }));
+}
+
+function createDynamicRelationshipFlow(action) {
+  const outputTopic = action !== 'GetRelationship';
+  const flowSteps = [
+    {
+      stepName: 'start',
+      properties: [],
+      messageAttributes: MESSAGE_ATTRIBUTES,
+      ...(outputTopic ? {
+        returnValues: {
+          properties: [],
+          messageAttributes: MESSAGE_ATTRIBUTES
+        }
+      } : {})
+    }
+  ];
+
+  if (outputTopic) {
+    flowSteps.push({
+      stepName: 'Complete',
+      event: ['extTopic'],
+      properties: [],
+      messageAttributes: MESSAGE_ATTRIBUTES
+    });
+  }
+
+  return {
+    flowTag: action,
+    isDynamicRelationshipType: true,
+    initiateBy: 'system',
+    handleObj: 'one',
+    statusType: 'none',
+    event: outputTopic
+      ? ['ownTopic']
+      : ['lambdaSyncInv', 'lambdaSyncApi', 'dsq', 'ownTopic'],
+    outputTopic,
+    stepMessageAttributes: {
+      userId: { propertyName: 'x-correlation-base-user-id', type: 'string' },
+      correlationId: { propertyName: 'x-correlation-id', type: 'string' }
+    },
+    flowSteps
+  };
+}

package/src/emit/relationship/emitRelationshipApplicationArtifacts.js

@@ -0,0 +1,147 @@
+import ejs from 'ejs';
+import { readFile } from 'node:fs/promises';
+
+import {
+  renderApiFunctionYaml,
+  renderInvFunctionYaml,
+  renderSqsFunctionYaml,
+  renderWbsFunctionYaml
+} from '../function/functionYamlArtifact.js';
+
+const ACTIONS = [
+  'CreateRelationship',
+  'UpdateRelationship',
+  'DeleteRelationship',
+  'GetRelationship',
+  'ChangeRelationship',
+  'MoveRelationship'
+];
+const YAML_PATH = 'app/sls_yaml/generatedCode/source/flow-relationships.yml';
+const TEMPLATE_URL = new URL('./templates/', import.meta.url);
+
+export async function emitRelationshipApplicationArtifacts({ relationships, flows = [], serviceTag }) {
+  if (!Array.isArray(relationships) || !Array.isArray(flows)) {
+    throw new TypeError('relationships and flows must be arrays');
+  }
+  if (relationships.length === 0) return [];
+
+  const handlers = await Promise.all(ACTIONS.map(action => emitAction(action, relationships, flows, serviceTag)));
+  return [
+    ...handlers.flatMap(handler => handler.artifacts),
+    { path: YAML_PATH, content: handlers.flatMap(handler => handler.functions).map(renderFunction).join('\n') }
+  ];
+}
+
+export function relationshipApplicationManagedPaths() {
+  return [
+    ...ACTIONS.flatMap(action => {
+      const source = `app/src/generatedCode/FlowRelationships/${action}/source`;
+      return [
+        `${source}/${action}_Main.js`,
+        `${source}/${action}_HdrSqs.js`,
+        `${source}/${action}_HdrDsq.js`,
+        `${source}/${action}_HdrApi.js`,
+        `${source}/${action}_HdrInv.js`,
+        `${source}/${action}_WbsMain.js`,
+        `${source}/${action}_HdrWbs.js`,
+        `${source}/${action}Complete_Main.js`,
+        `${source}/${action}Complete_HdrSqs.js`
+      ];
+    }),
+    YAML_PATH
+  ];
+}
+
+async function emitAction(action, relationships, flows, serviceTag) {
+  const source = `app/src/generatedCode/FlowRelationships/${action}/source`;
+  const handlerRoot = `src/generatedCode/FlowRelationships/${action}/source`;
+  const flow = flows.find(candidate => candidate?.flowTag === action);
+  const events = normalizeEvents(flow?.event, action === 'GetRelationship'
+    ? ['lambdaSyncInv', 'lambdaSyncApi', 'dsq', 'ownTopic']
+    : ['ownTopic']);
+  const shared = { flowTag: action, flowStepName: '', mainFileName: `${action}_Main`, functionName: action, startConfig: null };
+  const artifacts = [{ path: `${source}/${action}_Main.js`, content: await render(`${action}_Main.ejs`, { functionName: action, upperFunctionName: action }) }];
+  const functions = [];
+
+  if (events.includes('ownTopic')) {
+    artifacts.push(
+      { path: `${source}/${action}_WbsMain.js`, content: await renderShared('FlowMain_Wbs.ejs', { flowTag: action, upperCaseFlowTag: action, functionName: action }) },
+      { path: `${source}/${action}_HdrWbs.js`, content: await renderShared('FlowEndpoint_HdrWbs.ejs', { flowTag: action, upperCaseFlowTag: action, functionName: action, mainFileName: `${action}_WbsMain`, route: action }) }
+    );
+    functions.push({ type: 'wbs', functionName: `${action}HdrWbs`, handlerPath: `${handlerRoot}/${action}_HdrWbs.main`, roleName: 'FlowRelationshipRole', routeName: action });
+  }
+
+  for (const event of events) {
+    const handler = eventHandler(event, action, handlerRoot, relationships, serviceTag);
+    if (!handler) continue;
+    artifacts.push({ path: `${source}/${handler.fileName}.js`, content: await render(handler.template, { ...shared, queueName: handler.queueName }) });
+    functions.push(handler.descriptor);
+  }
+
+  const complete = `${action}Complete`;
+  artifacts.push(
+    { path: `${source}/${complete}_Main.js`, content: await render(`${action}Complete_Main.ejs`, { functionName: complete, upperFunctionName: complete }) },
+    { path: `${source}/${complete}_HdrSqs.js`, content: await renderShared('FlowHandler_HdrSqs.ejs', { ...shared, flowStepName: 'Complete', mainFileName: `${complete}_Main`, functionName: complete, queueName: `${complete}HdrSqs` }) }
+  );
+  functions.push({ type: 'sqs', functionName: `${action}CompleteHdrSqs`, handlerPath: `${handlerRoot}/${complete}_HdrSqs.main`, roleName: 'FlowRelationshipRole', queueName: `${complete}HdrSqs` });
+  return { artifacts, functions };
+}
+
+function eventHandler(event, action, handlerRoot, relationships, serviceTag) {
+  if (event === 'ownTopic' || event === 'extTopic') {
+    return {
+      fileName: `${action}_HdrSqs`, template: 'FlowHandler_HdrSqs.ejs', queueName: `${action}HdrSqs`,
+      descriptor: { type: 'sqs', functionName: `${action.replace('Relationship', 'Rel')}HdrSqs`, handlerPath: `${handlerRoot}/${action}_HdrSqs.main`, roleName: 'FlowRelationshipRole', queueName: `${action}HdrSqs` }
+    };
+  }
+  if (event === 'dsq') {
+    return {
+      fileName: `${action}_HdrDsq`, template: 'FlowHandler_HdrDsq.ejs', queueName: `${action}HdrDsq`,
+      descriptor: { type: 'sqs', functionName: `${action.replace('Relationship', 'Rel')}HdrDsq`, handlerPath: `${handlerRoot}/${action}_HdrDsq.main`, roleName: 'FlowRelationshipRole', queueName: `${action}HdrDsq` }
+    };
+  }
+  if (event === 'lambdaSyncInv') {
+    return {
+      fileName: `${action}_HdrInv`, template: 'FlowHandler_HdrInv.ejs',
+      descriptor: { type: 'inv', functionName: `${action.replace('Relationship', 'Rel')}HdrInv`, handlerPath: `${handlerRoot}/${action}_HdrInv.main`, roleName: 'FlowRelationshipRole' }
+    };
+  }
+  if (event === 'lambdaSyncApi') {
+    return {
+      fileName: `${action}_HdrApi`, template: 'FlowHandler_HdrApi.ejs',
+      descriptor: {
+        type: 'api', functionName: `${action.replace('Relationship', 'Rel')}HdrApi`, handlerPath: `${handlerRoot}/${action}_HdrApi.main`, roleName: 'FlowRelationshipRole',
+        routes: relationships.map(relationship => {
+          const name = relationship.relationshipTag ?? Object.keys(relationship)[0];
+          return { path: `/${serviceTag ?? '${self:custom.iz_serviceName}'}/${name}/${action.toLowerCase().replace('relationship', '')}`, upperName: upperFirst(name) };
+        })
+      }
+    };
+  }
+  return undefined;
+}
+
+function normalizeEvents(events, fallback) {
+  return events === undefined ? fallback : (Array.isArray(events) ? events : [events]);
+}
+
+function upperFirst(value) {
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+
+async function render(templateName, data) {
+  const template = await readFile(new URL(templateName, TEMPLATE_URL), 'utf8');
+  return ejs.render(template, data);
+}
+
+async function renderShared(templateName, data) {
+  const template = await readFile(new URL(`../crud/templates/${templateName}`, import.meta.url), 'utf8');
+  return ejs.render(template, data);
+}
+
+function renderFunction(descriptor) {
+  if (descriptor.type === 'api') return renderApiFunctionYaml(descriptor);
+  if (descriptor.type === 'inv') return renderInvFunctionYaml(descriptor);
+  if (descriptor.type === 'wbs') return renderWbsFunctionYaml(descriptor);
+  return renderSqsFunctionYaml(descriptor);
+}

package/src/emit/relationship/generateDynamicRelationshipFlowSchemas.js

@@ -0,0 +1,23 @@
+import { buildGenerationPlan } from '../../plan/buildGenerationPlan.js';
+import { commitArtifacts } from '../../output/commitArtifacts.js';
+import { compileProject } from '../../compile/compileProject.js';
+import { loadLocalSchemaDirectory } from '../../compile/loadSchemas.js';
+import {
+  dynamicRelationshipFlowSchemaPaths,
+  emitDynamicRelationshipFlowSchemas
+} from './emitDynamicRelationshipFlowSchemas.js';
+
+export async function generateDynamicRelationshipFlowSchemas(rootPath, options = {}) {
+  const project = compileProject({ ...options, rootPath });
+  // The legacy generator creates these endpoints even with no relationships. Load now to
+  // validate the V2 source-module contract before later slices consume relationship data.
+  await loadLocalSchemaDirectory(project, 'RelationshipSchemas');
+  const plan = buildGenerationPlan(
+    project,
+    emitDynamicRelationshipFlowSchemas(),
+    { managedPaths: dynamicRelationshipFlowSchemaPaths, managedScope: 'relationship-flow-schemas' }
+  );
+  const files = await commitArtifacts(plan);
+
+  return { project, files };
+}

package/src/emit/relationship/generateRelationshipApplicationArtifacts.js

@@ -0,0 +1,22 @@
+import { buildGenerationPlan } from '../../plan/buildGenerationPlan.js';
+import { commitArtifacts } from '../../output/commitArtifacts.js';
+import { compileProject } from '../../compile/compileProject.js';
+import { loadLocalSchemaDirectory } from '../../compile/loadSchemas.js';
+import {
+  emitRelationshipApplicationArtifacts,
+  relationshipApplicationManagedPaths
+} from './emitRelationshipApplicationArtifacts.js';
+
+export async function generateRelationshipApplicationArtifacts(rootPath, options = {}) {
+  const project = compileProject({ ...options, rootPath });
+  const [relationships, flows] = await Promise.all([
+    loadLocalSchemaDirectory(project, 'RelationshipSchemas'),
+    loadLocalSchemaDirectory(project, 'FlowSchemas')
+  ]);
+  const artifacts = await emitRelationshipApplicationArtifacts({ relationships, flows, serviceTag: project.serviceTag });
+  const files = await commitArtifacts(buildGenerationPlan(project, artifacts, {
+    managedPaths: relationshipApplicationManagedPaths(),
+    managedScope: 'relationship-application'
+  }));
+  return { project, files };
+}

package/src/{codeGenerators/app/src/generatedCode/Flow/FlowRelationships/templates/relationship/ProcessChangeRelationshipComplete_Main.ejs → emit/relationship/templates/ChangeRelationshipComplete_Main.ejs}

@@ -140,4 +140,4 @@ export default async function changeRelationshipComplete(
     _izContext.logger.error('error createRelationshipComplete:', err)
     throw (err)
   }
-}
+}

package/src/{codeGenerators/app/src/generatedCode/Flow/FlowRelationships/templates/relationship/ProcessChangeRelationship_Main.ejs → emit/relationship/templates/ChangeRelationship_Main.ejs}

@@ -126,7 +126,7 @@ export default async function <%- functionName %> (
     const oldRelationshipSchema = await getRelationshipSchemaWithCache(_izContext, oldRelTypeAndDirection.relType);
     _izContext.logger.debug("oldRelationshipSchema ", oldRelationshipSchema);
 
-    const newRelationshipSchema = await getRelationshipSchemaWithCache(_izContext, newRelType);
+    const newRelationshipSchema = await getRelationshipSchemaWithCache(_izContext, newRelType.relType);
     _izContext.logger.debug("newRelationshipSchema: ", newRelationshipSchema);
     if (!oldRelationshipSchema.hasOwnProperty('canChangeToRelTypes')) {
       errorsFound.push(`${oldRelTypeAndDirection.relType} not have property to change to another relType`);
@@ -138,6 +138,8 @@ export default async function <%- functionName %> (
           if (canChangeToRelType.relType.serviceTag === newRelType.serviceTag &&
             canChangeToRelType.relType.relationshipTag === newRelType.relationshipTag) {
             // check changeBy
+            // ? Legacy Code:
+            /*
             if (canChangeToRelType.changeBy === "user") {
               // if changeBy is user will check for importBatch callingFlow
               if (callingFlowConfig) {
@@ -146,6 +148,12 @@ export default async function <%- functionName %> (
                 }
               }
             }
+            */
+            // ? [Fix]: The legacy logic incorrectly blocked "user" from regular execution and allowed non-user values.
+            // ? It has been corrected to require changeBy === "user" for normal execution.
+            if (canChangeToRelType.changeBy !== "user") {
+              errorsFound.push(`CanChangeToRelType changeBy is not user`);
+            }
           }
         });
       };
@@ -383,4 +391,4 @@ export default async function <%- functionName %> (
     _izContext.logger.error('error ChangeRelationship: ', err)
     throw (err)
   }
-}
+}

package/src/{codeGenerators/app/src/generatedCode/Flow/FlowRelationships/templates/relationship/ProcessCreateRelationshipComplete_Main.ejs → emit/relationship/templates/CreateRelationshipComplete_Main.ejs}

@@ -141,4 +141,4 @@ export default async function createRelationshipComplete(
     _izContext.logger.error('error createRelationshipComplete:', err)
     throw (err)
   }
-}
+}

package/src/{codeGenerators/app/src/generatedCode/Flow/FlowRelationships/templates/relationship/ProcessCreateRelationship_Main.ejs → emit/relationship/templates/CreateRelationship_Main.ejs}

@@ -435,4 +435,4 @@ export default async function createRelationship(
     _izContext.logger.error('error updateRelationship: ', err)
     throw (err)
   }
-}
+}

package/src/{codeGenerators/app/src/generatedCode/Flow/FlowRelationships/templates/relationship/ProcessDeleteRelationshipComplete_Main.ejs → emit/relationship/templates/DeleteRelationshipComplete_Main.ejs}

@@ -123,4 +123,4 @@ export default async function deleteRelationshipComplete(
     _izContext.logger.error('error deleteRelationshipComplete:', err)
     throw (err)
   }
-}
+}

package/src/{codeGenerators/app/src/generatedCode/Flow/FlowRelationships/templates/relationship/ProcessDeleteRelationship_Main.ejs → emit/relationship/templates/DeleteRelationship_Main.ejs}

@@ -353,4 +353,4 @@ export default async function deleteRelationship(
     _izContext.logger.error('error deleteRelationship: ', err)
     throw (err)
   }
-}
+}

package/src/emit/relationship/templates/FlowHandler_HdrApi.ejs

@@ -0,0 +1,51 @@
+import { middlewareHandler as middleware, response } from "@izara_project/izara-middleware";
+import callingFlowSharedLib from '@izara_project/izara-core-library-calling-flow';
+
+import <%= functionName %> from './<%= mainFileName %>.js';
+
+const validatorSchema = {
+    //(<validatorSchema>)
+<% if (typeof startConfig !== 'undefined' && startConfig !== null && startConfig.properties && startConfig.properties.length > 0) { -%>
+    type: 'object',
+    properties: {
+    <% startConfig.properties.forEach(prop => { -%>
+        <%- prop.propertyName %>: { type: '<%- prop.type || 'string' %>' },
+    <% }) -%>
+    },
+    required: [ <%- startConfig.properties.filter(p => p.required !== false).map(p => `'${p.propertyName}'`).join(', ') %> ]
+<% } -%>
+    //(</validatorSchema>)
+};
+
+middleware.setValidatorSchema(validatorSchema, { noAuthorizer: true });
+
+/**
+ * GENERATED HANDLER: <%= flowStepName %> (Flow: <%= flowTag %>)
+ * Triggered by: API Gateway
+ */
+export const main = middleware.wrap(async (event, context) => {
+    event._izContext?.logger?.debug(`[${context.awsRequestId}] Received API request in <%= flowStepName %>`);
+
+    try {
+        const passOnProperties = [
+            event.body,
+            //(<additionalParams>)
+            //(</additionalParams>)
+            callingFlowSharedLib.addCallingFlowToPassOnProperties(event)
+        ];
+
+        const lambdaFunctionResponse = await <%= functionName %>(
+            event._izContext,
+            ...passOnProperties
+        );
+
+        if (lambdaFunctionResponse instanceof Error) {
+            return response.failure(lambdaFunctionResponse);
+        }
+
+        return response.success(lambdaFunctionResponse);
+    } catch (err) {
+        event._izContext?.logger?.error('Unhandled Error in <%= flowStepName %> API:', err);
+        return response.failure(err);
+    }
+});

package/src/{codeGenerators/app/src/generatedCode/Flow/_shared/handlers → emit/relationship/templates}/FlowHandler_HdrDsq.ejs

@@ -94,7 +94,7 @@ export const main = middleware.wrap(async (event, context) => {
 
         // add argument (to invoke lambda) to passOnProperties[]
         passOnProperties.push(record.body.Message);
-<% if (functionName.endsWith('Complete')) { %>
+<% if (typeof usePassBack === 'undefined' ? functionName.endsWith('Complete') : usePassBack) { %>
         passOnProperties.push(
           callingFlowSharedLib.addPassBackPropertiesToPassOnProperties(
             record.body.Message

package/src/emit/relationship/templates/FlowHandler_HdrInv.ejs

@@ -0,0 +1,45 @@
+import { middlewareHandler as middleware } from "@izara_project/izara-middleware";
+import callingFlowSharedLib from '@izara_project/izara-core-library-calling-flow';
+
+import <%= functionName %> from './<%= mainFileName %>.js';
+
+const validatorSchema = {
+    //(<validatorSchema>)
+<% if (typeof startConfig !== 'undefined' && startConfig !== null && startConfig.properties && startConfig.properties.length > 0) { -%>
+    type: 'object',
+    properties: {
+    <% startConfig.properties.forEach(prop => { -%>
+        <%- prop.propertyName %>: { type: '<%- prop.type || 'string' %>' },
+    <% }) -%>
+    },
+    required: [ <%- startConfig.properties.filter(p => p.required !== false).map(p => `'${p.propertyName}'`).join(', ') %> ]
+<% } -%>
+    //(</validatorSchema>)
+};
+
+middleware.setValidatorSchema(validatorSchema);
+
+/**
+ * GENERATED HANDLER: <%= flowStepName %> (Flow: <%= flowTag %>)
+ * Triggered by: Lambda Invocation
+ */
+export const main = middleware.wrap(async (event, context) => {
+    event._izContext?.logger?.debug(`[${context.awsRequestId}] Received Invocation in <%= flowStepName %>`);
+
+    try {
+        const passOnProperties = [
+            event,
+            //(<additionalParams>)
+            //(</additionalParams>)
+            callingFlowSharedLib.addCallingFlowToPassOnProperties(event)
+        ];
+
+        return await <%= functionName %>(
+            event._izContext,
+            ...passOnProperties
+        );
+    } catch (err) {
+        event._izContext?.logger?.error('Unhandled Error in <%= flowStepName %> Invocation:', err);
+        throw err;
+    }
+});

package/src/{codeGenerators/app/src/generatedCode/Flow/FlowRelationships/templates/relationship/ProcessGetRelationshipComplete_Main.ejs → emit/relationship/templates/GetRelationshipComplete_Main.ejs}

@@ -96,4 +96,4 @@ export default async function getRelationshipComplete(
     _izContext.logger.error('error GetRelationshipComplete:', err)
     throw (err)
   }
-}
+}

package/src/{codeGenerators/app/src/generatedCode/Flow/FlowRelationships/templates/relationship/ProcessGetRelationship_Main.ejs → emit/relationship/templates/GetRelationship_Main.ejs}

@@ -329,4 +329,4 @@ export default async function getRelationship(
     _izContext.logger.error('error getRelationship: ', err)
     throw (err)
   }
-}
+}

package/src/{codeGenerators/app/src/generatedCode/Flow/FlowRelationships/templates/relationship/ProcessMoveRelationship_Main.ejs → emit/relationship/templates/MoveRelationship_Main.ejs}

@@ -131,6 +131,8 @@ export default async function moveRelationship(
 
     if (!relationshipSchema.hasOwnProperty("moveBy") || relationshipSchema.moveBy === "none") {
       errorsFound.push(`relationship: ${relType.relationshipTag} can't move`);
+      // ? Legacy Code:
+      /*
     } else if (relationshipSchema.moveBy === "user") {
       if (callingFlowConfig) {
         if (callingFlowConfig.callingFlow !== "ImportDataTestExternalUpdateRelationshipHdrSqs") {
@@ -138,6 +140,12 @@ export default async function moveRelationship(
         }
       }
     }
+    */
+    // ? [Fix]: The legacy logic incorrectly blocked "user" from regular execution and allowed non-user values.
+    // ? It has been corrected to require moveBy === "user" for normal execution.
+    } else if (relationshipSchema.moveBy !== "user") {
+      errorsFound.push(`relationship: ${relType.relationshipTag} moveBy is not user`);
+    }
 
     const links = await findLinksByObjTypes(_izContext, [firstObject.objType, secondObject.objType], relationshipSchema.links)
     _izContext.logger.debug("links", links)
@@ -375,4 +383,4 @@ export default async function moveRelationship(
     _izContext.logger.error('error ChangeRelationship: ', err)
     throw (err)
   }
-}
+}

package/src/{codeGenerators/app/src/generatedCode/Flow/FlowRelationships/templates/relationship/ProcessUpdateRelationshipComplete_Main.ejs → emit/relationship/templates/UpdateRelationshipComplete_Main.ejs}

@@ -148,4 +148,4 @@ export default async function updateRelationshipComplete(
     _izContext.logger.error('error updateRelationshipComplete:', err)
     throw (err)
   }
-}
+}

package/src/{codeGenerators/app/src/generatedCode/Flow/FlowRelationships/templates/relationship/ProcessUpdateRelationship_Main.ejs → emit/relationship/templates/UpdateRelationship_Main.ejs}

@@ -403,4 +403,4 @@ export default async function updateRelationship(
     _izContext.logger.error('error updateRelationship: ', err)
     throw (err)
   }
-}
+}