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

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

@@ -0,0 +1,730 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { emitS3Flow } from '../../../src/emit/application/custom/customFlowS3.js';
+
+test('emitS3Flow with 3-step pipeline generates exactly 3 pairs of artifacts', async () => {
+  const mockFlow = {
+    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: 'CreatePreSignUrl', event: ['extTopic'] },
+      { stepName: 'ProcessAfterUpload', event: ['s3'] }
+    ]
+  };
+
+  const source = 'app/src/generatedCode/FlowSchemas/FeedChunkRecordUrl/source';
+  const handlerRoot = 'src/generatedCode/FlowSchemas/FeedChunkRecordUrl/source';
+
+  const result = await emitS3Flow(mockFlow, source, handlerRoot);
+
+  assert.equal(result.functions.length, 3);
+  const functionNames = result.functions.map((fn) => fn.split(':')[0].trim());
+  assert.deepEqual(functionNames, [
+    'FeedChunkRecordUrlHdrWbs',
+    'FeedChunkRecordUrlCreatePreSignUrlHdrSqs',
+    'FeedChunkRecordUrlProcessAfterUploadHdrS3'
+  ]);
+
+  const artifactPaths = result.artifacts.map((a) => a.path);
+  assert.ok(artifactPaths.includes(`${source}/FeedChunkRecordUrl_Main.js`));
+  assert.ok(artifactPaths.includes(`${source}/FeedChunkRecordUrl_HdrWbs.js`));
+  assert.ok(artifactPaths.includes(`${source}/FeedChunkRecordUrlCreatePreSignUrl_Main.js`));
+  assert.ok(artifactPaths.includes(`${source}/FeedChunkRecordUrlCreatePreSignUrl_HdrSqs.js`));
+  assert.ok(artifactPaths.includes(`${source}/FeedChunkRecordUrlProcessAfterUpload_Main.js`));
+  assert.ok(artifactPaths.includes(`${source}/FeedChunkRecordUrlProcessAfterUpload_HdrS3.js`));
+
+  const mainArtifact = result.artifacts.find(
+    (a) => a.path === `${source}/FeedChunkRecordUrl_Main.js`
+  );
+  assert.ok(
+    mainArtifact.content.includes("'FeedChunkRecordUrlCreatePreSignUrlHdrSqs'")
+  );
+
+  const sqsHdrArtifact = result.artifacts.find(
+    (a) => a.path === `${source}/FeedChunkRecordUrlCreatePreSignUrl_HdrSqs.js`
+  );
+  assert.ok(
+    sqsHdrArtifact.content.includes("required: ['objType', 'objInstanceFull']")
+  );
+
+  const sqsFunctionYaml = result.functions.find((fn) =>
+    fn.startsWith('FeedChunkRecordUrlCreatePreSignUrlHdrSqs:')
+  );
+  assert.ok(
+    sqsFunctionYaml.includes(
+      '${self:custom.iz_resourcePrefix}FeedChunkRecordUrlCreatePreSignUrlHdrSqs'
+    )
+  );
+});
+
+test('emitS3Flow with ADR-016 deferred-node pipeline generates correct 3 pairs of artifacts', async () => {
+  const mockFlow = {
+    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: 'ConfirmAfterUpload', event: ['extTopic'] }
+    ]
+  };
+
+  const source = 'app/src/generatedCode/FlowSchemas/FeedChunkRecordUrl/source';
+  const handlerRoot = 'src/generatedCode/FlowSchemas/FeedChunkRecordUrl/source';
+
+  const mockObjects = [
+    {
+      objectType: 'feedChunk',
+      belongTo: { serviceTag: 'vidFeedOperation', objectType: 'operation' }
+    }
+  ];
+  const result = await emitS3Flow(mockFlow, source, handlerRoot, {
+    objects: mockObjects
+  });
+
+  assert.equal(result.functions.length, 3);
+  const functionNames = result.functions.map((fn) => fn.split(':')[0].trim());
+  assert.deepEqual(functionNames, [
+    'FeedChunkRecordUrlHdrWbs',
+    'FeedChunkRecordUrlProcessAfterUploadHdrS3',
+    'FeedChunkRecordUrlConfirmAfterUploadHdrSqs'
+  ]);
+
+  const artifactPaths = result.artifacts.map((a) => a.path);
+  assert.ok(artifactPaths.includes(`${source}/FeedChunkRecordUrl_Main.js`));
+  assert.ok(artifactPaths.includes(`${source}/FeedChunkRecordUrl_HdrWbs.js`));
+  assert.ok(artifactPaths.includes(`${source}/FeedChunkRecordUrlProcessAfterUpload_Main.js`));
+  assert.ok(artifactPaths.includes(`${source}/FeedChunkRecordUrlProcessAfterUpload_HdrS3.js`));
+  assert.ok(artifactPaths.includes(`${source}/FeedChunkRecordUrlConfirmAfterUpload_Main.js`));
+  assert.ok(artifactPaths.includes(`${source}/FeedChunkRecordUrlConfirmAfterUpload_HdrSqs.js`));
+
+  const sqsFunctionYaml = result.functions.find((fn) =>
+    fn.startsWith('FeedChunkRecordUrlConfirmAfterUploadHdrSqs:')
+  );
+  assert.ok(
+    sqsFunctionYaml.includes(
+      '${self:custom.iz_resourcePrefix}FeedChunkRecordUrlConfirmAfterUploadHdrSqs'
+    )
+  );
+
+  const startMainArtifact = result.artifacts.find(
+    (a) => a.path === `${source}/FeedChunkRecordUrl_Main.js`
+  );
+  assert.ok(
+    startMainArtifact.content.includes('createPresignedPost'),
+    'Start_Main should generate S3 presigned post URL'
+  );
+  assert.ok(
+    startMainArtifact.content.includes('uuidv7'),
+    'Start_Main should generate identifier with uuidv7'
+  );
+  assert.ok(
+    !startMainArtifact.content.includes("snsTopicArnByFlowSchema(_izContext, 'Create_In')"),
+    'Start_Main must not publish to Create_In topic'
+  );
+  assert.ok(
+    startMainArtifact.content.includes("Bucket: 'video-record-temp'"),
+    'Start_Main must bind bucket directly from schema'
+  );
+  assert.ok(
+    !startMainArtifact.content.includes('process.env.iz_s3BucketName'),
+    'Start_Main must not fallback to environment variable'
+  );
+  assert.ok(
+    startMainArtifact.content.includes("['eq', '$x-amz-meta-operationId', targetOperationId]"),
+    'Start_Main must enforce operationId condition'
+  );
+  assert.ok(
+    startMainArtifact.content.includes('requestParams.targetIdentifiers?.operationId'),
+    'Start_Main should dynamically resolve operationId from belongTo schema'
+  );
+  assert.ok(
+    startMainArtifact.content.includes("throw new Error('targetIdentifiers.operationId is required')"),
+    'Start_Main should enforce targetIdentifiers.operationId is required'
+  );
+  assert.ok(
+    startMainArtifact.content.includes("const submittedByUserId = _izContext.correlationIds?.get("),
+    'Start_Main must extract submittedByUserId from correlationIds'
+  );
+  assert.ok(
+    startMainArtifact.content.includes("['starts-with', '$x-amz-meta-submittedByUserId', '']"),
+    'Start_Main must include x-amz-meta-submittedByUserId condition'
+  );
+  assert.ok(
+    startMainArtifact.content.includes("'x-amz-meta-submittedByUserId': submittedByUserId"),
+    'Start_Main must include x-amz-meta-submittedByUserId field'
+  );
+
+  const procMainArtifact = result.artifacts.find(
+    (a) => a.path === `${source}/FeedChunkRecordUrlProcessAfterUpload_Main.js`
+  );
+  assert.ok(
+    procMainArtifact.content.includes("snsTopicArnByFlowSchema(_izContext, 'Create_In')"),
+    'ProcessAfterUpload_Main must dispatch to Create_In topic'
+  );
+  assert.ok(
+    procMainArtifact.content.includes('operationId: parentId'),
+    'ProcessAfterUpload_Main should include parentIdKey in targetIdentifiers'
+  );
+  assert.ok(
+    procMainArtifact.content.includes('FeedChunkRecordUrlConfirmAfterUploadHdrSqs'),
+    'ProcessAfterUpload_Main must target ConfirmAfterUploadHdrSqs for callback'
+  );
+
+  const confirmMainArtifact = result.artifacts.find(
+    (a) => a.path === `${source}/FeedChunkRecordUrlConfirmAfterUpload_Main.js`
+  );
+  assert.ok(
+    confirmMainArtifact.content.includes('objInstanceFull'),
+    'ConfirmAfterUpload_Main must receive objInstanceFull'
+  );
+  assert.ok(
+    !confirmMainArtifact.content.includes('createPresignedPost'),
+    'ConfirmAfterUpload_Main must not generate presigned URLs'
+  );
+});
+
+test('emitS3Flow preserves legacy 5 parts when flowSteps has no steps or legacy 5 steps', async () => {
+  const legacyFlow = {
+    flowTag: 'FeedChunkRecordUrl',
+    initiateBy: 'user',
+    handleObj: 'one',
+    statusType: 'statusField',
+    event: ['s3'],
+    objType: {
+      objectType: 'feedChunk',
+      serviceTag: 'FeedChunk'
+    },
+    bucketName: 'video-record-temp'
+  };
+
+  const source = 'app/src/generatedCode/FlowSchemas/FeedChunkRecordUrl/source';
+  const handlerRoot = 'src/generatedCode/FlowSchemas/FeedChunkRecordUrl/source';
+
+  const result = await emitS3Flow(legacyFlow, source, handlerRoot);
+  assert.equal(result.functions.length, 5);
+
+  const legacySqsHdrArtifact = result.artifacts.find((a) =>
+    a.path.includes('CreatePreSignUrl_HdrSqs.js')
+  );
+  assert.ok(
+    legacySqsHdrArtifact.content.includes(
+      "required: ['returnMessage', 'foundErrors', 'passStatus']"
+    )
+  );
+
+  const legacySqsFunctionYaml = result.functions.find((fn) =>
+    fn.startsWith('FeedChunkRecordUrlCreatePreSignUrlHdrSqs:')
+  );
+  assert.ok(
+    legacySqsFunctionYaml.includes('CreatePresignUrlHdrSqs')
+  );
+});
+
+test('createResourceState generates SQS queue and SNS subscription for 3-step S3 flow', async () => {
+  const { createResourceState } = await import(
+    '../../../src/emit/infrastructure/resources/resourceState.js'
+  );
+
+  const mockFlow = {
+    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: 'CreatePreSignUrl', event: ['extTopic'] },
+      { stepName: 'ProcessAfterUpload', event: ['s3'] }
+    ]
+  };
+
+  const state = createResourceState({
+    objects: [],
+    relationships: [],
+    flows: [mockFlow]
+  });
+
+  assert.deepEqual(state.customSqsQueues, [
+    'FeedChunkRecordUrlCreatePreSignUrlHdrSqs'
+  ]);
+  assert.equal(state.s3Subscriptions.length, 1);
+  assert.equal(
+    state.s3Subscriptions[0].queueName,
+    'FeedChunkRecordUrlCreatePreSignUrlHdrSqs'
+  );
+  assert.equal(
+    state.s3Subscriptions[0].subscriptionName,
+    'SubscriptionOutCreateToFeedChunkRecordUrlCreatePreSignUrlHdrSqs'
+  );
+  assert.equal(state.s3Subscriptions[0].topicName, 'OutCreate');
+});
+
+test('roleTopicNames includes Create_In for S3 custom flow role', async () => {
+  const { roleTopicNames } = await import(
+    '../../../src/emit/infrastructure/resources/iamResourceArtifacts.js'
+  );
+
+  const mockFlow = {
+    flowTag: 'FeedChunkRecordUrl',
+    event: ['s3'],
+    flowSteps: [
+      { stepName: 'Start', event: ['wbs'] },
+      { stepName: 'CreatePreSignUrl', event: ['extTopic'] },
+      { stepName: 'ProcessAfterUpload', event: ['s3'] }
+    ]
+  };
+
+  const state = {
+    flows: [mockFlow],
+    outTopics: []
+  };
+
+  const topics = roleTopicNames(state, 'FeedChunkRecordUrlRole');
+  assert.ok(topics.includes('Create_In'));
+});
+
+test('createResourceState generates SQS queue and SNS subscription for ADR-016 deferred-node flow', async () => {
+  const { createResourceState } = await import(
+    '../../../src/emit/infrastructure/resources/resourceState.js'
+  );
+
+  const mockFlow = {
+    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: 'ConfirmAfterUpload', event: ['extTopic'] }
+    ]
+  };
+
+  const state = createResourceState({
+    objects: [],
+    relationships: [],
+    flows: [mockFlow]
+  });
+
+  assert.deepEqual(state.customSqsQueues, [
+    'FeedChunkRecordUrlConfirmAfterUploadHdrSqs'
+  ]);
+  assert.equal(state.s3Subscriptions.length, 1);
+  assert.equal(
+    state.s3Subscriptions[0].queueName,
+    'FeedChunkRecordUrlConfirmAfterUploadHdrSqs'
+  );
+  assert.equal(
+    state.s3Subscriptions[0].subscriptionName,
+    'SubscriptionOutCreateToFeedChunkRecordUrlConfirmAfterUploadHdrSqs'
+  );
+  assert.equal(state.s3Subscriptions[0].topicName, 'OutCreate');
+});
+
+test('emitS3Flow with ConfirmComplete step generates correct artifacts and SQS filter', async () => {
+  const mockFlow = {
+    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 source = 'app/src/generatedCode/FlowSchemas/FeedChunkRecordUrl/source';
+  const handlerRoot = 'src/generatedCode/FlowSchemas/FeedChunkRecordUrl/source';
+
+  const result = await emitS3Flow(mockFlow, source, handlerRoot);
+
+  assert.equal(result.functions.length, 3);
+  const functionNames = result.functions.map((fn) => fn.split(':')[0].trim());
+  assert.deepEqual(functionNames, [
+    'FeedChunkRecordUrlHdrWbs',
+    'FeedChunkRecordUrlProcessAfterUploadHdrS3',
+    'FeedChunkRecordUrlConfirmCompleteHdrSqs'
+  ]);
+
+  const artifactPaths = result.artifacts.map((a) => a.path);
+  assert.ok(artifactPaths.includes(`${source}/FeedChunkRecordUrl_Main.js`));
+  assert.ok(artifactPaths.includes(`${source}/FeedChunkRecordUrl_HdrWbs.js`));
+  assert.ok(artifactPaths.includes(`${source}/FeedChunkRecordUrlProcessAfterUpload_Main.js`));
+  assert.ok(artifactPaths.includes(`${source}/FeedChunkRecordUrlProcessAfterUpload_HdrS3.js`));
+  assert.ok(artifactPaths.includes(`${source}/FeedChunkRecordUrlConfirmComplete_Main.js`));
+  assert.ok(artifactPaths.includes(`${source}/FeedChunkRecordUrlConfirmComplete_HdrSqs.js`));
+
+  const sqsFunctionYaml = result.functions.find((fn) =>
+    fn.startsWith('FeedChunkRecordUrlConfirmCompleteHdrSqs:')
+  );
+  assert.ok(
+    sqsFunctionYaml.includes(
+      '${self:custom.iz_resourcePrefix}FeedChunkRecordUrlConfirmCompleteHdrSqs'
+    )
+  );
+
+  const procMainArtifact = result.artifacts.find(
+    (a) => a.path === `${source}/FeedChunkRecordUrlProcessAfterUpload_Main.js`
+  );
+  assert.ok(
+    procMainArtifact.content.includes('FeedChunkRecordUrlConfirmCompleteHdrSqs'),
+    'ProcessAfterUpload_Main must target ConfirmCompleteHdrSqs for callback'
+  );
+});
+
+test('emitS3Flow generates auto RBAC check, parameter groups hook, and file parameter extraction in Start_Main.js', async () => {
+  const mockFlow = {
+    flowTag: 'FeedChunkRecordUrl',
+    initiateBy: 'user',
+    handleObj: 'one',
+    statusType: 'statusField',
+    event: ['s3'],
+    objType: {
+      objectType: 'feedChunk',
+      serviceTag: 'FeedChunk'
+    },
+    bucketName: 'video-record-temp',
+    contentTypePrefix: 'video/',
+    maxFileSizeMb: 50,
+    s3KeyPrefix: 'uploads/',
+    createBucket: false,
+    flowSteps: [
+      { stepName: 'Start', event: ['wbs'] },
+      { stepName: 'ProcessAfterUpload', event: ['s3'] },
+      { stepName: 'ConfirmComplete', event: ['extTopic'] }
+    ]
+  };
+
+  const mockObjects = [
+    {
+      objectType: 'feedChunk',
+      belongTo: { serviceTag: 'vidFeedOperation', objectType: 'operation' }
+    }
+  ];
+
+  const source = 'app/src/generatedCode/FlowSchemas/FeedChunkRecordUrl/source';
+  const handlerRoot = 'src/generatedCode/FlowSchemas/FeedChunkRecordUrl/source';
+
+  const result = await emitS3Flow(mockFlow, source, handlerRoot, {
+    objects: mockObjects
+  });
+
+  const startMainArtifact = result.artifacts.find(
+    (a) => a.path === `${source}/FeedChunkRecordUrl_Main.js`
+  );
+  assert.ok(startMainArtifact, 'FeedChunkRecordUrl_Main.js should be generated');
+
+  // RBAC checks
+  assert.ok(
+    startMainArtifact.content.includes('checkRbacPermission'),
+    'Start_Main must auto-generate checkRbacPermission'
+  );
+  assert.ok(
+    startMainArtifact.content.includes('//(<rbacParameterGroups_FeedChunkRecordUrl>)'),
+    'Start_Main must include rbacParameterGroups hook'
+  );
+  assert.ok(
+    startMainArtifact.content.includes('targetIdentifiers: requestParams.targetIdentifiers,'),
+    'Start_Main must use targetIdentifiers: requestParams.targetIdentifiers'
+  );
+  assert.ok(
+    startMainArtifact.content.includes("serviceTag: 'vidFeedOperation'"),
+    'Start_Main must target parent serviceTag for RBAC'
+  );
+  assert.ok(
+    startMainArtifact.content.includes("objectType: 'operation'"),
+    'Start_Main must target parent objectType for RBAC'
+  );
+
+  // File parameter extraction
+  assert.ok(
+    startMainArtifact.content.includes("let importType = 'mp4'"),
+    'Start_Main should infer default importType mp4 from video/ prefix'
+  );
+  assert.ok(
+    startMainArtifact.content.includes('requestParams.file?.size'),
+    'Start_Main should extract maxFileSizeMb from file.size'
+  );
+  assert.ok(
+    startMainArtifact.content.includes("let uploadPath = '';"),
+    'Start_Main should initialize uploadPath to empty string inside createKeyForUploadFile hook'
+  );
+
+  // Conditions & Fields
+  assert.ok(
+    startMainArtifact.content.includes("['starts-with', '$Content-Type', 'video/']"),
+    'Start_Main must enforce starts-with video/ condition'
+  );
+  assert.ok(
+    !startMainArtifact.content.includes("'Content-Type': `video/${importType}`"),
+    'Start_Main must omit fixed Content-Type from Fields to allow dynamic client Content-Type'
+  );
+});
+
+test('emitS3Flow supports composite identifiers with 2 keys', async () => {
+  const flow = {
+    flowTag: 'FeedChunkRecordUrl',
+    flowType: 'custom',
+    event: ['s3'],
+    bucketName: 'video-record-temp',
+    contentTypePrefix: 'video/',
+    maxFileSizeMb: 50,
+    objType: {
+      objectType: 'feedChunk',
+      serviceTag: 'FeedChunk'
+    },
+    belongTo: {
+      serviceTag: 'vidFeedOperation',
+      objectType: 'operation',
+      identifiers: ['operationId', 'subId']
+    },
+    flowSteps: [
+      { stepName: 'Start', event: ['wbs'] },
+      { stepName: 'ProcessAfterUpload', event: ['s3'] },
+      { stepName: 'ConfirmAfterUpload', event: ['sqs'] }
+    ]
+  };
+
+  const objects = [
+    {
+      objectType: 'feedChunk',
+      belongTo: {
+        serviceTag: 'vidFeedOperation',
+        objectType: 'operation',
+        identifiers: ['operationId', 'subId']
+      }
+    }
+  ];
+
+  const source = 'app/src/generatedCode/FlowSchemas/FeedChunkRecordUrl/source';
+  const handlerRoot = 'src/generatedCode/FlowSchemas/FeedChunkRecordUrl/source';
+
+  const result = await emitS3Flow(flow, source, handlerRoot, {
+    objects
+  });
+  const startMain = result.artifacts.find(
+    (a) => a.path === `${source}/FeedChunkRecordUrl_Main.js`
+  );
+
+  assert.ok(
+    startMain.content.includes('requestParams.targetIdentifiers?.operationId'),
+    'Start_Main should extract operationId'
+  );
+  assert.ok(
+    startMain.content.includes('requestParams.targetIdentifiers?.subId'),
+    'Start_Main should extract subId'
+  );
+  assert.ok(
+    startMain.content.includes("throw new Error('targetIdentifiers.operationId is required')"),
+    'Start_Main should validate operationId'
+  );
+  assert.ok(
+    startMain.content.includes("throw new Error('targetIdentifiers.subId is required')"),
+    'Start_Main should validate subId'
+  );
+  assert.ok(
+    startMain.content.includes("['eq', '$x-amz-meta-operationId', targetOperationId]"),
+    'Start_Main should include condition for operationId'
+  );
+  assert.ok(
+    startMain.content.includes("['eq', '$x-amz-meta-subId', targetSubId]"),
+    'Start_Main should include condition for subId'
+  );
+  assert.ok(
+    startMain.content.includes("'x-amz-meta-operationId': targetOperationId"),
+    'Start_Main should include field for operationId'
+  );
+  assert.ok(
+    startMain.content.includes("'x-amz-meta-subId': targetSubId"),
+    'Start_Main should include field for subId'
+  );
+
+  const procMain = result.artifacts.find(
+    (a) => a.path === `${source}/FeedChunkRecordUrlProcessAfterUpload_Main.js`
+  );
+  assert.ok(
+    procMain.content.includes('operationId: parentId,'),
+    'ProcessAfterUpload_Main should include first parentId key'
+  );
+  assert.ok(
+    procMain.content.includes('subId: subId'),
+    'ProcessAfterUpload_Main should include second parentId key'
+  );
+});
+
+test('extractIdentifierFieldNames correctly parses partitionKey, sortKey, and composite fieldNames', async () => {
+  const { extractIdentifierFieldNames } = await import(
+    '../../../src/emit/application/custom/customFlowS3.js'
+  );
+
+  const dynamoIdentifiers = [
+    {
+      type: 'partitionKey',
+      fieldNames: ['companyId', 'deptId'],
+      deliminator: '_',
+      name: 'pk'
+    },
+    {
+      type: 'sortKey',
+      fieldName: 'operationId',
+      name: 'sk'
+    }
+  ];
+  assert.deepEqual(extractIdentifierFieldNames(dynamoIdentifiers), [
+    'companyId',
+    'deptId',
+    'operationId'
+  ]);
+
+  const graphIdentifiers = [
+    {
+      type: 'identifier',
+      fieldName: 'operationId'
+    }
+  ];
+  assert.deepEqual(extractIdentifierFieldNames(graphIdentifiers), [
+    'operationId'
+  ]);
+});
+
+test('emitS3Flow automatically resolves partitionKey and sortKey from parent schema in objects', async () => {
+  const flow = {
+    flowTag: 'FeedChunkRecordUrl',
+    flowType: 'custom',
+    event: ['s3'],
+    bucketName: 'video-record-temp',
+    contentTypePrefix: 'video/',
+    maxFileSizeMb: 50,
+    objType: {
+      objectType: 'feedChunk',
+      serviceTag: 'FeedChunk'
+    },
+    flowSteps: [
+      { stepName: 'Start', event: ['wbs'] },
+      { stepName: 'ProcessAfterUpload', event: ['s3'] },
+      { stepName: 'ConfirmAfterUpload', event: ['sqs'] }
+    ]
+  };
+
+  const parentOperationObj = {
+    objectType: 'operation',
+    identifiers: [
+      {
+        type: 'partitionKey',
+        fieldName: 'operationId'
+      },
+      {
+        type: 'sortKey',
+        fieldName: 'versionId'
+      }
+    ]
+  };
+
+  const childFeedChunkObj = {
+    objectType: 'feedChunk',
+    belongTo: {
+      serviceTag: 'vidFeedOperation',
+      objectType: 'operation'
+    }
+  };
+
+  const source = 'app/src/generatedCode/FlowSchemas/FeedChunkRecordUrl/source';
+  const handlerRoot = 'src/generatedCode/FlowSchemas/FeedChunkRecordUrl/source';
+
+  const result = await emitS3Flow(flow, source, handlerRoot, {
+    objects: [childFeedChunkObj, parentOperationObj]
+  });
+
+  const startMain = result.artifacts.find(
+    (a) => a.path === `${source}/FeedChunkRecordUrl_Main.js`
+  );
+
+  assert.ok(
+    startMain.content.includes("throw new Error('targetIdentifiers.operationId is required')"),
+    'Start_Main should validate partitionKey operationId from parent schema'
+  );
+  assert.ok(
+    startMain.content.includes("throw new Error('targetIdentifiers.versionId is required')"),
+    'Start_Main should validate sortKey versionId from parent schema'
+  );
+  assert.ok(
+    startMain.content.includes("['eq', '$x-amz-meta-operationId', targetOperationId]"),
+    'Start_Main should include condition for partitionKey'
+  );
+  assert.ok(
+    startMain.content.includes("['eq', '$x-amz-meta-versionId', targetVersionId]"),
+    'Start_Main should include condition for sortKey'
+  );
+});
+
+test('emitS3Flow with ADR-016 pipeline without step-level event enum resolves correctly', async () => {
+  const mockFlow = {
+    flowTag: 'FeedChunkRecordUrl',
+    initiateBy: 'user',
+    handleObj: 'one',
+    statusType: 'statusField',
+    event: ['s3'],
+    objType: {
+      objectType: 'feedChunk',
+      serviceTag: 'FeedChunk'
+    },
+    bucketName: 'video-record-temp',
+    flowSteps: [
+      { stepName: 'Start' },
+      { stepName: 'ProcessAfterUpload' },
+      { stepName: 'ConfirmComplete', event: ['extTopic'] }
+    ]
+  };
+
+  const source = 'app/src/generatedCode/FlowSchemas/FeedChunkRecordUrl/source';
+  const handlerRoot = 'src/generatedCode/FlowSchemas/FeedChunkRecordUrl/source';
+
+  const result = await emitS3Flow(mockFlow, source, handlerRoot);
+
+  assert.equal(result.functions.length, 3);
+  const functionNames = result.functions.map((fn) => fn.split(':')[0].trim());
+  assert.deepEqual(functionNames, [
+    'FeedChunkRecordUrlHdrWbs',
+    'FeedChunkRecordUrlProcessAfterUploadHdrS3',
+    'FeedChunkRecordUrlConfirmCompleteHdrSqs'
+  ]);
+});
+
+
+
+