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

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

@@ -131,8 +131,8 @@ test('emitS3Flow with ADR-016 deferred-node pipeline generates correct 3 pairs o
     'Start_Main should generate S3 presigned post URL'
   );
   assert.ok(
-    startMainArtifact.content.includes('uuidv7'),
-    'Start_Main should generate identifier with uuidv7'
+    startMainArtifact.content.includes('identifierUuid'),
+    'Start_Main should generate identifier with identifierUuid'
   );
   assert.ok(
     !startMainArtifact.content.includes("snsTopicArnByFlowSchema(_izContext, 'Create_In')"),
@@ -186,6 +186,10 @@ test('emitS3Flow with ADR-016 deferred-node pipeline generates correct 3 pairs o
     procMainArtifact.content.includes('FeedChunkRecordUrlConfirmAfterUploadHdrSqs'),
     'ProcessAfterUpload_Main must target ConfirmAfterUploadHdrSqs for callback'
   );
+  assert.ok(
+    procMainArtifact.content.includes('feedChunkId: rawId'),
+    'ProcessAfterUpload_Main must include objectTypeId: rawId in fieldNames'
+  );
 
   const confirmMainArtifact = result.artifacts.find(
     (a) => a.path === `${source}/FeedChunkRecordUrlConfirmAfterUpload_Main.js`
@@ -725,6 +729,284 @@ 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'
+  );
+});
+
+test('emitS3Flow generates WebSocketTask atomic claim in ProcessAfterUpload and connectionId NONE guard in ConfirmComplete', 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 source = 'app/src/generatedCode/FlowSchemas/FeedChunkRecordUrl/source';
+  const handlerRoot = 'src/generatedCode/FlowSchemas/FeedChunkRecordUrl/source';
+
+  const result = await emitS3Flow(flow, source, handlerRoot);
+
+  const procMain = result.artifacts.find(
+    (a) => a.path === `${source}/FeedChunkRecordUrlProcessAfterUpload_Main.js`
+  );
+  assert.ok(
+    procMain.content.includes('attribute_exists(taskKey) AND attribute_not_exists(uploadClaimed)'),
+    'ProcessAfterUpload_Main must enforce attribute_exists(taskKey) AND attribute_not_exists(uploadClaimed)'
+  );
+  assert.ok(
+    procMain.content.includes("status: 'unauthorized_or_unknown_upload'"),
+    'ProcessAfterUpload_Main must abort when task record is missing'
+  );
+  assert.ok(
+    procMain.content.includes('dynamodbSharedLib'),
+    'ProcessAfterUpload_Main must import dynamodbSharedLib for simplified S3'
+  );
+
+  assert.ok(
+    procMain.content.includes("status: 'skipped_empty_or_dir'"),
+    'ProcessAfterUpload_Main must guard against directory markers or 0-byte files'
+  );
+
+  const confirmMain = result.artifacts.find(
+    (a) => a.path === `${source}/FeedChunkRecordUrlConfirmComplete_Main.js`
+  );
+  assert.ok(
+    confirmMain.content.includes("taskRecord.connectionId !== 'NONE'"),
+    'ConfirmComplete_Main must guard against connectionId NONE'
+  );
+});
+
+test('resolveTargetIdentifierInfo resolves both DynamoDB and Graph identifier formats', async () => {
+  const { resolveTargetIdentifierInfo } = await import(
+    '../../../src/emit/application/custom/customFlowS3.js'
+  );
+
+  // 1. Graph style: { type: 'identifier', fieldName: 'chunkUuid' }
+  const graphFlow = { objType: { objectType: 'feedChunk' } };
+  const graphObjects = [
+    {
+      objectType: 'feedChunk',
+      identifiers: [{ type: 'identifier', fieldName: 'chunkUuid' }]
+    }
+  ];
+  const graphResult = resolveTargetIdentifierInfo(graphFlow, graphObjects);
+  assert.equal(graphResult.identifierKey, 'chunkUuid');
+  assert.deepEqual(graphResult.identifierKeys, ['chunkUuid']);
+
+  // 2. DynamoDB style: { type: 'partitionKey', fieldName: 'myFeedId' }
+  const dynamoFlow = { objType: { objectType: 'feedChunk' } };
+  const dynamoObjects = [
+    {
+      objectType: 'feedChunk',
+      identifiers: [{ type: 'partitionKey', fieldName: 'myFeedId' }]
+    }
+  ];
+  const dynamoResult = resolveTargetIdentifierInfo(dynamoFlow, dynamoObjects);
+  assert.equal(dynamoResult.identifierKey, 'myFeedId');
+  assert.deepEqual(dynamoResult.identifierKeys, ['myFeedId']);
+
+  // 3. Fallback when no identifiers defined
+  const emptyFlow = { objType: { objectType: 'videoFeed' } };
+  const emptyResult = resolveTargetIdentifierInfo(emptyFlow, []);
+  assert.equal(emptyResult.identifierKey, 'videoFeedId');
+  assert.deepEqual(emptyResult.identifierKeys, ['videoFeedId']);
+});
+
+test('emitS3Flow generates dynamic identifier name for both Start_Main and ProcessAfterUpload_Main', 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: 'ConfirmComplete', event: ['sqs'] }
+    ]
+  };
+
+  const customObjects = [
+    {
+      objectType: 'feedChunk',
+      identifiers: [
+        {
+          type: 'identifier',
+          fieldName: 'customChunkId'
+        }
+      ]
+    }
+  ];
+
+  const source = 'app/src/generatedCode/FlowSchemas/FeedChunkRecordUrl/source';
+  const handlerRoot = 'src/generatedCode/FlowSchemas/FeedChunkRecordUrl/source';
+
+  const result = await emitS3Flow(flow, source, handlerRoot, {
+    objects: customObjects
+  });
+
+  const startMain = result.artifacts.find(
+    (a) => a.path === `${source}/FeedChunkRecordUrl_Main.js`
+  );
+  assert.ok(
+    startMain.content.includes('const customChunkId = identifierUuid()'),
+    'Start_Main must bind custom identifier key'
+  );
+  assert.ok(
+    startMain.content.includes("'x-amz-meta-customChunkId': customChunkId"),
+    'Start_Main must use custom identifier key in S3 metadata'
+  );
+
+  const procMain = result.artifacts.find(
+    (a) => a.path === `${source}/FeedChunkRecordUrlProcessAfterUpload_Main.js`
+  );
+  assert.ok(
+    procMain.content.includes('customChunkId: rawId'),
+    'ProcessAfterUpload_Main must use custom identifier key in fieldNames and identifiers'
+  );
+});
+
+
 
 
 

package/test/unit/infrastructure/resourceArtifacts.test.js

@@ -97,6 +97,10 @@ test('emits queues, topics, tables, and IAM roles from schema data', async () =>
     dynamoYaml,
     /RunningTotalReservedUsageTable:\s+Type: 'AWS::DynamoDB::Table'[\s\S]+TableName: \${self:custom\.iz_resourcePrefix}RunningTotalReservedUsage/
   );
+  assert.match(
+    dynamoYaml,
+    /Outputs:\s+RunningTotalReservedUsageStreamArn:\s+Value:\s+Fn::GetAtt: \[RunningTotalReservedUsageTable, StreamArn\]\s+Export:\s+Name: \${self:custom\.iz_resourcePrefix}RunningTotalReservedUsageStreamArn/
+  );
   const iam = await readFile(
     join(
       rootPath,