@izara_project/izara-core-generate-service-code 1.0.100 → 1.0.101

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izara_project/izara-core-generate-service-code",
-  "version": "1.0.100",
+  "version": "1.0.101",
   "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/emit/application/crud/templates/CreateLogicalLib.ejs

@@ -140,6 +140,12 @@ export async function resolveSchemaAndIdentity(_izContext, requestParams, foundE
   }
 
   requestParams.submittedByUserId = submittedByUserId;
+  if (submittedByUserId) {
+    _izContext.correlationIds?.set(
+      coreConsts.SUBMITTED_BY_USER_ID,
+      submittedByUserId
+    );
+  }
   return { objType, objectSchema, targetIdentifiers };
 }
 

package/src/emit/application/custom/customFlowS3.js

@@ -27,7 +27,7 @@ export async function emitS3Flow(
   flow,
   source,
   handlerRoot,
-  { objects = [] } = {}
+  { objects = [], relationships = [] } = {}
 ) {
   const tag = upperFirst(flow.flowTag);
   const roleName = customFlowRoleName(flow.flowTag);
@@ -71,7 +71,8 @@ export async function emitS3Flow(
             functionName,
             nextStepFunctionName,
             isSimplifiedS3,
-            objects
+            objects,
+            relationships
           })
         );
         const handlerContent = await renderCustom(
@@ -260,13 +261,182 @@ export function resolveParentIdentifierInfo(flow, objects = []) {
   };
 }
 
+export function resolveFlowRelationships(
+  flow,
+  { objects = [], relationships = [] } = {}
+) {
+  if (Array.isArray(flow.relationships) && flow.relationships.length > 0) {
+    const list = [];
+    for (const rel of flow.relationships) {
+      let targetObj = {
+        objectType: '',
+        serviceTag: ''
+      };
+      if (rel.targetObjType) {
+        targetObj = {
+          objectType: rel.targetObjType.objectType || '',
+          serviceTag: rel.targetObjType.serviceTag || ''
+        };
+      } else if (rel.objectType) {
+        targetObj = {
+          objectType: rel.objectType,
+          serviceTag: rel.serviceTag || ''
+        };
+      }
+
+      let relType = {
+        relationshipTag: '',
+        serviceTag: targetObj.serviceTag
+      };
+      if (rel.relType) {
+        relType = {
+          relationshipTag: rel.relType.relationshipTag || '',
+          serviceTag: rel.relType.serviceTag || targetObj.serviceTag
+        };
+      } else if (rel.relationshipTag) {
+        relType = {
+          relationshipTag: rel.relationshipTag,
+          serviceTag: rel.serviceTag || targetObj.serviceTag
+        };
+      }
+
+      let targetIdentifierKey = '';
+      if (rel.targetIdentifierKey) {
+        targetIdentifierKey = rel.targetIdentifierKey;
+      } else if (rel.targetIdentifiers) {
+        const idKeys = Object.keys(rel.targetIdentifiers);
+        if (idKeys.length > 0) {
+          targetIdentifierKey = idKeys[0];
+        }
+      }
+      if (!targetIdentifierKey && targetObj.objectType) {
+        targetIdentifierKey = `${targetObj.objectType}Id`;
+      }
+
+      let direction = 'to';
+      if (rel.relationshipDirection) {
+        direction = rel.relationshipDirection;
+      }
+
+      list.push({
+        targetObjType: targetObj,
+        relType,
+        targetIdentifierKey,
+        relationshipProperties: rel.relationshipProperties || {},
+        relationshipDirection: direction
+      });
+    }
+    return list;
+  }
+
+  let targetObjType = '';
+  if (typeof flow.objType === 'string') {
+    targetObjType = flow.objType;
+  } else if (flow.objType?.objectType) {
+    targetObjType = flow.objType.objectType;
+  } else if (flow.objectType) {
+    targetObjType = flow.objectType;
+  }
+
+  if (
+    !targetObjType ||
+    !Array.isArray(relationships) ||
+    relationships.length === 0
+  ) {
+    return [];
+  }
+
+  const resolved = [];
+  for (const relItem of relationships) {
+    if (!relItem || typeof relItem !== 'object') {
+      continue;
+    }
+
+    if (
+      relItem.objectType &&
+      relItem.objectType.toLowerCase() === targetObjType.toLowerCase() &&
+      relItem.relationshipTag &&
+      relItem.relationshipServiceTag
+    ) {
+      const parentService = relItem.relationshipServiceTag;
+      let parentObjType = '';
+      if (relItem.targetObjectType) {
+        parentObjType = relItem.targetObjectType;
+      } else if (parentService.length > 0) {
+        parentObjType =
+          parentService[0].toLowerCase() + parentService.slice(1);
+      }
+      let targetIdentifierKey = `${parentObjType}Id`;
+      if (relItem.targetIdentifierKey) {
+        targetIdentifierKey = relItem.targetIdentifierKey;
+      }
+      let direction = 'to';
+      if (relItem.relationshipDirection) {
+        direction = relItem.relationshipDirection;
+      }
+      resolved.push({
+        targetObjType: {
+          objectType: parentObjType,
+          serviceTag: parentService
+        },
+        relType: {
+          relationshipTag: relItem.relationshipTag,
+          serviceTag: parentService
+        },
+        targetIdentifierKey,
+        relationshipProperties: {},
+        relationshipDirection: direction
+      });
+      continue;
+    }
+
+    const relKeys = Object.keys(relItem);
+    for (const relTag of relKeys) {
+      const relDef = relItem[relTag];
+      if (!relDef || !Array.isArray(relDef.links)) {
+        continue;
+      }
+      for (const link of relDef.links) {
+        if (!link || !link.from || !link.to) {
+          continue;
+        }
+
+        const isToTarget =
+          link.to.objType?.objectType?.toLowerCase() ===
+          targetObjType.toLowerCase();
+        if (isToTarget && link.to.requiredOnCreate) {
+          const fromObj = link.from.objType || {};
+          const fromObjType = fromObj.objectType || '';
+          const targetIdentifierKey = `${fromObjType}Id`;
+          resolved.push({
+            targetObjType: {
+              objectType: fromObjType,
+              serviceTag: fromObj.serviceTag || ''
+            },
+            relType: {
+              relationshipTag: relTag,
+              serviceTag: fromObj.serviceTag || ''
+            },
+            targetIdentifierKey,
+            relationshipProperties: {},
+            relationshipDirection: 'to'
+          });
+        }
+      }
+    }
+  }
+
+  return resolved;
+}
+
 function _s3TemplateData({
   action,
   flow,
   functionName,
   nextStepFunctionName,
   isSimplifiedS3,
-  objects = []
+  objects = [],
+  relationships = []
 }) {
   let maxFileSizeMb = 50;
   if (flow.maxFileSizeMb) {
@@ -293,9 +463,15 @@ function _s3TemplateData({
     defaultImportType = flow.defaultImportType;
   } else if (flow.importType) {
     defaultImportType = flow.importType;
-  } else if (typeof contentTypePrefix === 'string' && contentTypePrefix.startsWith('video/')) {
+  } else if (
+    typeof contentTypePrefix === 'string' &&
+    contentTypePrefix.startsWith('video/')
+  ) {
     defaultImportType = 'mp4';
-  } else if (typeof contentTypePrefix === 'string' && contentTypePrefix.startsWith('image/')) {
+  } else if (
+    typeof contentTypePrefix === 'string' &&
+    contentTypePrefix.startsWith('image/')
+  ) {
     defaultImportType = 'jpg';
   }
 
@@ -313,6 +489,11 @@ function _s3TemplateData({
     rbacServiceTag = flow.objType?.serviceTag || flow.serviceTag || 'Rbac';
   }
 
+  const flowRelationships = resolveFlowRelationships(flow, {
+    objects,
+    relationships
+  });
+
   return {
     action,
     flowTag: flow.flowTag,
@@ -331,7 +512,8 @@ function _s3TemplateData({
     parentIdKeys,
     defaultImportType,
     isRbac,
-    rbacServiceTag
+    rbacServiceTag,
+    flowRelationships
   };
 }
 

package/src/emit/application/custom/emitCustomFlowApplicationArtifacts.js

@@ -35,7 +35,7 @@ export { customFlowApplicationManagedPaths };
 
 export async function emitCustomFlowApplicationArtifacts(
   flows,
-  { objects = [] } = {}
+  { objects = [], relationships = [] } = {}
 ) {
   const customFlows = supportedCustomFlows(flows);
   const generatedRoots = generatedOwnTopicFlows(flows);
@@ -51,7 +51,7 @@ export async function emitCustomFlowApplicationArtifacts(
   }
 
   const emitted = await Promise.all(
-    customFlows.map((flow) => emitFlow(flow, objects))
+    customFlows.map((flow) => emitFlow(flow, objects, relationships))
   );
   const roots = await Promise.all(
     generatedRoots.map((flow) => emitOwnTopicRoot(flow, objects))
@@ -77,7 +77,7 @@ export async function emitCustomFlowApplicationArtifacts(
   ];
 }
 
-async function emitFlow(flow, objects) {
+async function emitFlow(flow, objects, relationships = []) {
   const tag = upperFirst(flow.flowTag);
   const process = tag;
   const source = `app/src/generatedCode/FlowSchemas/${tag}/source`;
@@ -202,7 +202,8 @@ async function emitFlow(flow, objects) {
   }
   if (flow.event.includes('s3')) {
     const s3Artifacts = await emitS3Flow(flow, source, handlerRoot, {
-      objects
+      objects,
+      relationships
     });
     artifacts.push(...s3Artifacts.artifacts);
     functions.push(...s3Artifacts.functions);

package/src/emit/application/custom/templates/s3/ConfirmAfterUpload_HdrSqs.ejs

@@ -95,6 +95,7 @@ export const main = middleware.wrap(async (event, context) => {
         let returnPromise = await recordHandlerSharedLib.recordHandler(
           record,
           <%= functionName %>,
+          '<%= functionName %><%= handlerType %>',
           passOnProperties
         );
 

package/src/emit/application/custom/templates/s3/ConfirmComplete_HdrSqs.ejs

@@ -95,6 +95,7 @@ export const main = middleware.wrap(async (event, context) => {
         let returnPromise = await recordHandlerSharedLib.recordHandler(
           record,
           <%= functionName %>,
+          '<%= functionName %><%= handlerType %>',
           passOnProperties
         );
 

package/src/emit/application/custom/templates/s3/ConfirmComplete_Main.ejs

@@ -50,32 +50,43 @@ export default async function <%- functionName %>(
       passBackProperties
     });
 
-    const targetId =
-      objInstanceFull.identifiers?.<%- objectType %>Id ||
-      Object.values(objInstanceFull.identifiers || {})[0];
+    let targetId =
+      passBackProperties.rawId ||
+      passBackProperties.<%- objectType %>Id ||
+      passBackProperties.parentPassBackProperties?.rawId ||
+      passBackProperties.parentPassBackProperties?.<%- objectType %>Id ||
+      objInstanceFull?.identifiers?.<%- objectType %>Id;
+
+    if (!targetId && objInstanceFull?.identifiers) {
+      targetId = Object.values(objInstanceFull.identifiers)[0];
+    }
 
     //(<confirmUsageHook>)
     //(</confirmUsageHook>)
 
     const taskKey = `${createFlowTypeConcat(_izContext, { flowTag: '<%- flowTag %>', serviceTag: process.env.iz_serviceTag })}${targetId}`;
-    const taskRecord = await dynamodbSharedLib.getItem(
+    const tasks = await dynamodbSharedLib.query(
       _izContext,
       await dynamodbSharedLib.tableName(_izContext, 'WebSocketTask'),
-      { taskKey: taskKey }
+      { taskKey }
     );
 
-    if (taskRecord && taskRecord.connectionId) {
-      await postToConnection(
-        _izContext,
-        {
-          status: 'completed',
-          data: {
-            <%- objectType %>Id: targetId,
-            objInstanceFull: objInstanceFull
-          }
-        },
-        taskRecord.connectionId
-      );
+    if (tasks && tasks.Items && tasks.Items.length > 0) {
+      for (const taskRecord of tasks.Items) {
+        if (taskRecord.connectionId) {
+          await postToConnection(
+            _izContext,
+            {
+              status: 'completed',
+              data: {
+                <%- objectType %>Id: targetId,
+                objInstanceFull: objInstanceFull
+              }
+            },
+            taskRecord.connectionId
+          );
+        }
+      }
     }
 
     return {

package/src/emit/application/custom/templates/s3/ProcessS3File_Main.ejs

@@ -26,6 +26,7 @@ import snsSharedLib from '@izara_project/izara-core-library-sns';
 import callingFlowSharedLib from '@izara_project/izara-core-library-calling-flow';
 import lambdaSharedLib from '@izara_project/izara-core-library-lambda';
 import { sns } from '@izara_project/izara-core-library-external-request';
+import { consts } from '@izara_project/izara-middleware';
 
 //(<optionalRequired>)
 //(</optionalRequired>)
@@ -33,7 +34,8 @@ import { sns } from '@izara_project/izara-core-library-external-request';
 /**
  * Step 2: ProcessAfterUpload (Deferred-Node S3 Pipeline - ADR-016)
  * Triggered by S3 ObjectCreated event. Inspects file, prepares entity payload,
- * and publishes to Create_In SNS topic with callingFlow targeting ConfirmAfterUpload.
+ * and publishes to Create_In SNS topic with callingFlow
+ * targeting ConfirmAfterUpload.
  *
  * @param {Object} _izContext
  * @param {Object} bucket - S3 bucket record
@@ -50,7 +52,15 @@ export default async function <%- functionName %>(
   passBackProperties = {}
 ) {
   try {
-    _izContext.logger.debug('----- <%- functionName %> started -----', {
+    _izContext.logger.info(
+      '----- <%- functionName %> started -----',
+      {
+        bucketName: bucket.name,
+        key: field.key,
+        size: field.size
+      }
+    );
+    _izContext.logger.debug('<%- functionName %> incoming parameters:', {
       bucket,
       field,
       passBackProperties
@@ -60,6 +70,12 @@ export default async function <%- functionName %>(
     const actualByteSize = field.size;
     const actualSizeMb = actualByteSize / (1024 * 1024);
 
+    _izContext.logger.debug('S3 file details:', {
+      s3Key,
+      actualByteSize,
+      actualSizeMb
+    });
+
     let s3Metadata = {};
     try {
       const headResult = await s3.send(
@@ -68,13 +84,19 @@ export default async function <%- functionName %>(
           Key: s3Key
         })
       );
+
+      _izContext.logger.debug('HeadObjectCommand raw result:', headResult);
       s3Metadata = headResult.Metadata || {};
+      _izContext.logger.info('Parsed S3 Metadata:', { s3Metadata });
     } catch (headErr) {
-      _izContext.logger.warn('Could not retrieve S3 object metadata via HeadObjectCommand:', {
-        bucket: bucket.name,
-        key: s3Key,
-        error: headErr.message
-      });
+      _izContext.logger.warn(
+        'Could not retrieve S3 object metadata via HeadObjectCommand:',
+        {
+          bucket: bucket.name,
+          key: s3Key,
+          error: headErr.message
+        }
+      );
     }
 
     //(<extractIdentifiersFromKeyOrMetadata>)
@@ -102,13 +124,70 @@ export default async function <%- functionName %>(
     //(</endpointHook>)
 
 <% if (typeof nextStepFunctionName === 'string' && nextStepFunctionName) { -%>
-    const metaUserId =
-      s3Metadata.submittedbyuserid ||
-      s3Metadata.submittedByUserId ||
-      s3Metadata.userid ||
-      s3Metadata.userId ||
-      _izContext.userId ||
-      '';
+    const metaUserId = s3Metadata.submittedbyuserid || '';
+<% if (typeof flowRelationships !== 'undefined' && Array.isArray(flowRelationships) && flowRelationships.length > 0) { -%>
+<%   for (const rel of flowRelationships) { -%>
+<%     const targetIdKey = rel.targetIdentifierKey || `${rel.targetObjType.objectType}Id`; -%>
+<%     const metaKey = targetIdKey.toLowerCase(); -%>
+    const meta<%- targetIdKey.charAt(0).toUpperCase() + targetIdKey.slice(1) %> = s3Metadata.<%- metaKey %> || '';
+<%   } -%>
+<% } -%>
+
+    _izContext.logger.info('Extracted identifiers and metadata:', {
+      <%- objectType %>Id: rawId,
+      parentId,
+      submittedByUserId: metaUserId,
+<% if (typeof flowRelationships !== 'undefined' && Array.isArray(flowRelationships) && flowRelationships.length > 0) { -%>
+<%   for (const rel of flowRelationships) { -%>
+<%     const targetIdKey = rel.targetIdentifierKey || `${rel.targetObjType.objectType}Id`; -%>
+      <%- targetIdKey %>: meta<%- targetIdKey.charAt(0).toUpperCase() + targetIdKey.slice(1) %>,
+<%   } -%>
+<% } -%>
+      fileName: fileNameWithExt
+    });
+
+    if (metaUserId) {
+      _izContext.correlationIds?.set(consts.SUBMITTED_BY_USER_ID, metaUserId);
+    }
+
+    //(<relationshipsHook>)
+    let relationships = [];
+<% if (typeof flowRelationships !== 'undefined' && Array.isArray(flowRelationships) && flowRelationships.length > 0) { -%>
+<%   for (const rel of flowRelationships) { -%>
+<%     const targetIdKey = rel.targetIdentifierKey || `${rel.targetObjType.objectType}Id`; -%>
+<%     const targetObj = rel.targetObjType || {}; -%>
+<%     const relTypeObj = rel.relType || {}; -%>
+<%     const relDir = rel.relationshipDirection || 'to'; -%>
+<%     const varName = `meta${targetIdKey.charAt(0).toUpperCase() + targetIdKey.slice(1)}`; -%>
+    if (<%- varName %>) {
+      relationships.push({
+        targetObjType: {
+          objectType: '<%- targetObj.objectType %>',
+          serviceTag: '<%- targetObj.serviceTag %>'
+        },
+        targetIdentifiers: {
+          <%- targetIdKey %>: <%- varName %>
+        },
+        relType: {
+          relationshipTag: '<%- relTypeObj.relationshipTag %>',
+          serviceTag: '<%- relTypeObj.serviceTag %>'
+        },
+        relationshipProperties: <%- JSON.stringify(rel.relationshipProperties || {}) %>,
+        relationshipDirection: '<%- relDir %>'
+      });
+      _izContext.logger.info('Built relationship for <%- targetObj.objectType %>:', {
+        relationships
+      });
+    } else {
+      _izContext.logger.warn(
+        '<%- varName %> is empty! ' +
+          'No <%- relTypeObj.relationshipTag %> relationship attached.'
+      );
+    }
+<%   } -%>
+<% } -%>
+    //(</relationshipsHook>)
+
     let messageObject = {
       objectType: '<%- objectType %>',
       submittedByUserId: metaUserId,
@@ -127,37 +206,62 @@ export default async function <%- functionName %>(
         <%- parentIdKey %>: parentId
       },
 <% } -%>
+      relationships,
       fieldNames: {
         //(<fieldNamesHook>)
         //(</fieldNamesHook>)
+        fileName: fileNameWithExt
       }
     };
 
+    const confirmCallbackFunction =
+      await lambdaSharedLib.lambdaFunctionName(
+        _izContext,
+        '<%- nextStepFunctionName %>'
+      );
+    _izContext.logger.debug('Resolved confirm callback function:', {
+      confirmCallbackFunction
+    });
+
     messageObject =
       callingFlowSharedLib.addCallingFlowToSnsRequestMessageObject(
         messageObject,
         callingFlowSharedLib.addParentCallingFlowConfig(
           passBackProperties,
           callingFlowSharedLib.createCallingFlowConfig(
-            await lambdaSharedLib.lambdaFunctionName(
-              _izContext,
-              '<%- nextStepFunctionName %>'
-            ),
-            {}
+            confirmCallbackFunction,
+            { rawId: rawId, <%- objectType %>Id: rawId }
           )
         )
       );
 
+    const topicArn =
+      snsSharedLib.snsTopicArnByFlowSchema(_izContext, 'Create_In');
+
     let sendMessageToCreateEndpoint = {
       Message: JSON.stringify(messageObject),
-      TopicArn: snsSharedLib.snsTopicArnByFlowSchema(_izContext, 'Create_In')
+      TopicArn: topicArn
     };
 
+    _izContext.logger.info('Publishing to Create_In SNS topic:', {
+      topicArn,
+      <%- objectType %>Id: rawId,
+      parentId<%- (typeof flowRelationships !== 'undefined' && Array.isArray(flowRelationships) && flowRelationships.length > 0) ? flowRelationships.map(r => { const k = r.targetIdentifierKey || `${r.targetObjType.objectType}Id`; return `,\n      ${k}: meta${k.charAt(0).toUpperCase() + k.slice(1)}`; }).join('') : '' %>
+    });
     _izContext.logger.debug(
-      'sendMessageToCreateEndpoint',
+      'Full Create_In message payload:',
       sendMessageToCreateEndpoint
     );
-    await sns.publishAsync(_izContext, sendMessageToCreateEndpoint);
+
+    const publishResult = await sns.publishAsync(
+      _izContext,
+      sendMessageToCreateEndpoint
+    );
+    _izContext.logger.info('Successfully published to Create_In SNS:', {
+      publishResult,
+      s3Key,
+      <%- objectType %>Id: rawId
+    });
 
     return {
       status: 'dispatched',
@@ -175,3 +279,4 @@ export default async function <%- functionName %>(
     throw err;
   }
 }
+

package/src/emit/application/custom/templates/s3/Start_Main.ejs

@@ -123,6 +123,13 @@ export default async function <%- functionName %>(
     //(<createKeyForUploadFile>)
     let importType = '<%- defaultImportType %>';
     let uploadPath = '';
+<% if (typeof flowRelationships !== 'undefined' && Array.isArray(flowRelationships) && flowRelationships.length > 0) { -%>
+<%   for (const rel of flowRelationships) { -%>
+<%     const relIdKey = rel.targetIdentifierKey || `${rel.targetObjType.objectType}Id`; -%>
+    const <%- relIdKey %> =
+      requestParams.fieldNames?.<%- relIdKey %> || requestParams.file?.<%- relIdKey %>;
+<%   } -%>
+<% } -%>
     //(</createKeyForUploadFile>)
     const Key = `<%- s3KeyPrefix %>${uploadPath}`;
     const maximumSize = maxFileSizeMb * 1048576;
@@ -139,7 +146,13 @@ export default async function <%- functionName %>(
 <%   } -%>
 <% } -%>
         ['starts-with', '$x-amz-meta-submittedByUserId', ''],
-        ['starts-with', '$Content-Type', '<%- contentTypePrefix %>']
+        ['starts-with', '$Content-Type', '<%- contentTypePrefix %>'],
+<% if (typeof flowRelationships !== 'undefined' && Array.isArray(flowRelationships) && flowRelationships.length > 0) { -%>
+<%   for (const rel of flowRelationships) { -%>
+<%     const relIdKey = rel.targetIdentifierKey || `${rel.targetObjType.objectType}Id`; -%>
+        ['starts-with', '$x-amz-meta-<%- relIdKey %>', ''],
+<%   } -%>
+<% } -%>
         //(<conditionCreateUrlLink>)
         //(</conditionCreateUrlLink>)
       ],
@@ -151,6 +164,12 @@ export default async function <%- functionName %>(
 <%   } -%>
 <% } -%>
         'x-amz-meta-submittedByUserId': submittedByUserId,
+<% if (typeof flowRelationships !== 'undefined' && Array.isArray(flowRelationships) && flowRelationships.length > 0) { -%>
+<%   for (const rel of flowRelationships) { -%>
+<%     const relIdKey = rel.targetIdentifierKey || `${rel.targetObjType.objectType}Id`; -%>
+        'x-amz-meta-<%- relIdKey %>': <%- relIdKey %> || '',
+<%   } -%>
+<% } -%>
         //(<fieldCreateUrlLink>)
         //(</fieldCreateUrlLink>)
       },

package/src/plan/domainRegistry.js

@@ -145,7 +145,8 @@ export async function resolveEmissionGroups(context) {
   ]);
 
   const custom = await emitCustomFlowApplicationArtifacts(flows, {
-    objects
+    objects,
+    relationships
   });
 
   let systemFunctions = [];

package/test/unit/application/customFlowS3.test.js

@@ -725,6 +725,134 @@ test('emitS3Flow with ADR-016 pipeline without step-level event enum resolves co
   ]);
 });
 
+test('emitS3Flow generates relationships with direction to in ProcessAfterUpload_Main and fields in Start_Main', async () => {
+  const flowWithRel = {
+    flowTag: 'FeedChunkRecordUrl',
+    initiateBy: 'user',
+    handleObj: 'one',
+    statusType: 'statusField',
+    event: ['s3'],
+    objType: {
+      objectType: 'feedChunk',
+      serviceTag: 'FeedChunk'
+    },
+    bucketName: 'video-record-temp',
+    flowSteps: [
+      { stepName: 'Start', event: ['wbs'] },
+      { stepName: 'ProcessAfterUpload', event: ['s3'] },
+      { stepName: 'ConfirmComplete', event: ['extTopic'] }
+    ],
+    relationships: [
+      {
+        targetObjType: { objectType: 'videoFeed', serviceTag: 'VideoFeed' },
+        targetIdentifierKey: 'videoFeedId',
+        relType: { relationshipTag: 'hasFeedChunk', serviceTag: 'VideoFeed' },
+        relationshipDirection: 'to'
+      }
+    ]
+  };
+
+  const source = 'app/src/generatedCode/FlowSchemas/FeedChunkRecordUrl/source';
+  const handlerRoot = 'src/generatedCode/FlowSchemas/FeedChunkRecordUrl/source';
+
+  const result = await emitS3Flow(flowWithRel, source, handlerRoot);
+
+  const startMain = result.artifacts.find(
+    (a) => a.path === `${source}/FeedChunkRecordUrl_Main.js`
+  );
+  assert.ok(
+    startMain.content.includes("requestParams.fieldNames?.videoFeedId"),
+    'Start_Main should extract videoFeedId from requestParams'
+  );
+  assert.ok(
+    startMain.content.includes("['starts-with', '$x-amz-meta-videoFeedId', '']"),
+    'Start_Main should include videoFeedId condition in Presigned POST'
+  );
+  assert.ok(
+    startMain.content.includes("'x-amz-meta-videoFeedId': videoFeedId || ''"),
+    'Start_Main should include videoFeedId field in Presigned POST'
+  );
+
+  const procMain = result.artifacts.find(
+    (a) => a.path === `${source}/FeedChunkRecordUrlProcessAfterUpload_Main.js`
+  );
+  assert.ok(
+    procMain.content.includes("const metaVideoFeedId = s3Metadata.videofeedid || '';"),
+    'ProcessAfterUpload_Main should extract metaVideoFeedId from s3Metadata'
+  );
+  assert.ok(
+    procMain.content.includes("videoFeedId: metaVideoFeedId"),
+    'ProcessAfterUpload_Main should include videoFeedId in extracted metadata log'
+  );
+  assert.ok(
+    procMain.content.includes("objectType: 'videoFeed'"),
+    'ProcessAfterUpload_Main should include targetObjType objectType'
+  );
+  assert.ok(
+    procMain.content.includes("relationshipTag: 'hasFeedChunk'"),
+    'ProcessAfterUpload_Main should include relType relationshipTag'
+  );
+  assert.ok(
+    procMain.content.includes("relationshipDirection: 'to'"),
+    'ProcessAfterUpload_Main must generate relationshipDirection to'
+  );
+  assert.ok(
+    procMain.content.includes('Built relationship for videoFeed'),
+    'ProcessAfterUpload_Main should log relationship construction'
+  );
+});
+
+test('emitS3Flow resolves relationships from schemas with relationshipDirection to', async () => {
+  const flow = {
+    flowTag: 'FeedChunkRecordUrl',
+    initiateBy: 'user',
+    handleObj: 'one',
+    statusType: 'statusField',
+    event: ['s3'],
+    objType: {
+      objectType: 'feedChunk',
+      serviceTag: 'FeedChunk'
+    },
+    bucketName: 'video-record-temp',
+    flowSteps: [
+      { stepName: 'Start', event: ['wbs'] },
+      { stepName: 'ProcessAfterUpload', event: ['s3'] },
+      { stepName: 'ConfirmComplete', event: ['extTopic'] }
+    ]
+  };
+
+  const relationshipsSchema = [
+    {
+      objectType: 'feedChunk',
+      relationshipTag: 'hasFeedChunk',
+      relationshipServiceTag: 'VideoFeed'
+    }
+  ];
+
+  const source = 'app/src/generatedCode/FlowSchemas/FeedChunkRecordUrl/source';
+  const handlerRoot = 'src/generatedCode/FlowSchemas/FeedChunkRecordUrl/source';
+
+  const result = await emitS3Flow(flow, source, handlerRoot, {
+    relationships: relationshipsSchema
+  });
+
+  const procMain = result.artifacts.find(
+    (a) => a.path === `${source}/FeedChunkRecordUrlProcessAfterUpload_Main.js`
+  );
+  assert.ok(
+    procMain.content.includes("relationshipDirection: 'to'"),
+    'ProcessAfterUpload_Main should infer relationshipDirection to from RefObjectRelationships'
+  );
+  assert.ok(
+    procMain.content.includes("relationshipTag: 'hasFeedChunk'"),
+    'ProcessAfterUpload_Main should infer relationshipTag hasFeedChunk'
+  );
+  assert.ok(
+    procMain.content.includes("serviceTag: 'VideoFeed'"),
+    'ProcessAfterUpload_Main should infer serviceTag VideoFeed'
+  );
+});
+