SIMSBIOHUB-847: Storing Feature Content Array (#332)

* Storing Feature Content Array

* Lint files

* Fix text/lint issue

* Refactor for Sonarcloud

* Rename columns per requirements

* Lint files

* Address feedback

Author: dylanrogowsky-oxd

api/src/repositories/submission-repository.test.ts

@@ -1620,4 +1620,100 @@ describe('SubmissionRepository', () => {
       expect(sqlStub).to.have.been.calledOnce;
     });
   });
+
+  describe('deleteSubmissionFeatureRelationships', () => {
+    afterEach(() => {
+      sinon.restore();
+    });
+
+    it('should delete relationship rows for features belonging to the submission', async () => {
+      const mockQueryResponse: QueryResult<never> = {
+        rowCount: 5,
+        rows: [],
+        command: '',
+        oid: 0,
+        fields: []
+      };
+
+      const sqlStub = sinon.stub().resolves(mockQueryResponse);
+      const mockDBConnection = getMockDBConnection({ sql: sqlStub });
+
+      const submissionRepository = new SubmissionRepository(mockDBConnection);
+
+      await submissionRepository.deleteSubmissionFeatureRelationships(1);
+
+      expect(sqlStub).to.have.been.calledOnce;
+      const calledSql = sqlStub.args[0][0];
+      expect(calledSql.text).to.include('submission_feature_feature');
+      expect(calledSql.text).to.include('submission_id');
+    });
+  });
+
+  describe('insertSubmissionFeatureRelationships', () => {
+    afterEach(() => {
+      sinon.restore();
+    });
+
+    it('should insert relationship pairs', async () => {
+      const sqlStub = sinon.stub().resolves({ rowCount: 2, rows: [] });
+      const mockDBConnection = getMockDBConnection({ sql: sqlStub });
+
+      const submissionRepository = new SubmissionRepository(mockDBConnection);
+
+      await submissionRepository.insertSubmissionFeatureRelationships([
+        { source_feature_id: 1, target_feature_id: 2 },
+        { source_feature_id: 1, target_feature_id: 3 }
+      ]);
+
+      expect(sqlStub).to.have.been.calledOnce;
+      const calledSql = sqlStub.args[0][0];
+      expect(calledSql.text).to.include('submission_feature_feature');
+      expect(calledSql.text).to.include('ON CONFLICT');
+    });
+
+    it('should not execute SQL when pairs array is empty', async () => {
+      const sqlStub = sinon.stub().resolves({ rowCount: 0, rows: [] });
+      const mockDBConnection = getMockDBConnection({ sql: sqlStub });
+
+      const submissionRepository = new SubmissionRepository(mockDBConnection);
+
+      await submissionRepository.insertSubmissionFeatureRelationships([]);
+
+      expect(sqlStub).not.to.have.been.called;
+    });
+  });
+
+  describe('getRelatedSubmissionFeatureIds', () => {
+    afterEach(() => {
+      sinon.restore();
+    });
+
+    it('should return source and target IDs for a feature', async () => {
+      const mockParentResponse = {
+        rows: [{ source_feature_id: 10 }],
+        rowCount: 1
+      };
+      const mockChildResponse = {
+        rows: [{ target_feature_id: 2 }, { target_feature_id: 3 }],
+        rowCount: 2
+      };
+
+      const sqlStub = sinon
+        .stub()
+        .onFirstCall()
+        .resolves(mockParentResponse)
+        .onSecondCall()
+        .resolves(mockChildResponse);
+
+      const mockDBConnection = getMockDBConnection({ sql: sqlStub });
+
+      const submissionRepository = new SubmissionRepository(mockDBConnection);
+
+      const result = await submissionRepository.getRelatedSubmissionFeatureIds(1);
+
+      expect(result.sourceIds).to.deep.equal([10]);
+      expect(result.targetIds).to.deep.equal([2, 3]);
+      expect(sqlStub).to.have.been.calledTwice;
+    });
+  });
 });

api/src/repositories/submission-repository.ts

@@ -480,6 +480,92 @@ export class SubmissionRepository extends BaseRepository {
     await this.connection.sql(sqlStatement);
   }
 
+  /**
+   * Delete all submission feature relationships for features belonging to a submission.
+   * Used for idempotency - allows job retries to start fresh.
+   *
+   * @param {number} submissionId The submission ID.
+   * @return {Promise<void>}
+   * @memberof SubmissionRepository
+   */
+  async deleteSubmissionFeatureRelationships(submissionId: number): Promise<void> {
+    const sqlStatement = SQL`
+      DELETE FROM submission_feature_feature
+      WHERE source_feature_id IN (
+        SELECT submission_feature_id FROM submission_feature WHERE submission_id = ${submissionId}
+      )
+      OR target_feature_id IN (
+        SELECT submission_feature_id FROM submission_feature WHERE submission_id = ${submissionId}
+      );
+    `;
+
+    await this.connection.sql(sqlStatement);
+  }
+
+  /**
+   * Insert submission feature relationships (source-target from content array).
+   * Uses ON CONFLICT DO NOTHING to avoid failures on duplicate pairs.
+   *
+   * @param {Array<{ source_feature_id: number; target_feature_id: number }>} pairs The pairs to insert.
+   * @return {Promise<void>}
+   * @memberof SubmissionRepository
+   */
+  async insertSubmissionFeatureRelationships(
+    pairs: Array<{ source_feature_id: number; target_feature_id: number }>
+  ): Promise<void> {
+    if (pairs.length === 0) {
+      return;
+    }
+
+    const sourceIds = pairs.map((p) => p.source_feature_id);
+    const targetIds = pairs.map((p) => p.target_feature_id);
+
+    const sqlStatement = SQL`
+      INSERT INTO submission_feature_feature (source_feature_id, target_feature_id)
+      SELECT source_id, target_id FROM unnest(
+        ${sourceIds}::integer[],
+        ${targetIds}::integer[]
+      ) AS t(source_id, target_id)
+      ON CONFLICT (source_feature_id, target_feature_id) DO NOTHING;
+    `;
+
+    await this.connection.sql(sqlStatement);
+  }
+
+  /**
+   * Get all related submission feature IDs for a given feature (sources and targets).
+   * sourceIds = features that reference this one; targetIds = features this one references.
+   *
+   * @param {number} submissionFeatureId The submission feature ID.
+   * @return {Promise<{ sourceIds: number[]; targetIds: number[] }>}
+   * @memberof SubmissionRepository
+   */
+  async getRelatedSubmissionFeatureIds(
+    submissionFeatureId: number
+  ): Promise<{ sourceIds: number[]; targetIds: number[] }> {
+    const parentSqlStatement = SQL`
+      SELECT source_feature_id
+      FROM submission_feature_feature
+      WHERE target_feature_id = ${submissionFeatureId};
+    `;
+
+    const childSqlStatement = SQL`
+      SELECT target_feature_id
+      FROM submission_feature_feature
+      WHERE source_feature_id = ${submissionFeatureId};
+    `;
+
+    const [parentResult, childResult] = await Promise.all([
+      this.connection.sql<{ source_feature_id: number }>(parentSqlStatement),
+      this.connection.sql<{ target_feature_id: number }>(childSqlStatement)
+    ]);
+
+    return {
+      sourceIds: parentResult.rows.map((r) => r.source_feature_id),
+      targetIds: childResult.rows.map((r) => r.target_feature_id)
+    };
+  }
+
   /**
    * Get feature type id by name.
    *

api/src/services/feature-ingestion-service.test.ts

@@ -670,13 +670,20 @@ describe('FeatureIngestionService', () => {
         .resolves(mockFeatureTypeWithProperties);
 
       const deleteStub = sinon.stub(SubmissionRepository.prototype, 'deleteSubmissionFeatures').resolves();
+      const deleteRelationshipsStub = sinon
+        .stub(SubmissionRepository.prototype, 'deleteSubmissionFeatureRelationships')
+        .resolves();
 
       const insertStub = sinon.stub(SubmissionRepository.prototype, 'insertSubmissionFeatureRecord');
       insertStub.onFirstCall().resolves({ submission_feature_id: 100 });
       insertStub.onSecondCall().resolves({ submission_feature_id: 101 });
 
       const updateParentStub = sinon.stub(SubmissionRepository.prototype, 'updateSubmissionFeatureParent').resolves();
 
+      const insertRelationshipsStub = sinon
+        .stub(SubmissionRepository.prototype, 'insertSubmissionFeatureRelationships')
+        .resolves();
+
       const features: IFlattenedBlock[] = [
         createValidFeature({ id: 'uuid-1', content: ['uuid-2'] }),
         createValidFeature({ id: 'uuid-2', parent: 'uuid-1', content: [] })
@@ -687,8 +694,10 @@ describe('FeatureIngestionService', () => {
       expect(result.valid).to.be.true;
       expect(result.errors).to.have.length(0);
       expect(deleteStub).to.have.been.calledOnceWith(1);
+      expect(deleteRelationshipsStub).to.have.been.calledOnceWith(1);
       expect(insertStub).to.have.been.calledTwice;
       expect(updateParentStub).to.have.been.calledOnceWith(101, 100);
+      expect(insertRelationshipsStub).to.have.been.calledOnceWith([{ source_feature_id: 100, target_feature_id: 101 }]);
     });
 
     it('should return all errors when validation fails', async () => {
@@ -1037,7 +1046,7 @@ describe('FeatureIngestionService', () => {
       expect(insertStub.secondCall.args[4]).to.deep.equal(propsMinimal);
     });
 
-    it('should call deleteSubmissionFeatures before inserting', async () => {
+    it('should call deleteSubmissionFeatures and deleteSubmissionFeatureRelationships before inserting', async () => {
       const mockDBConnection = getMockDBConnection();
       const service = new FeatureIngestionService(mockDBConnection);
 
@@ -1051,6 +1060,12 @@ describe('FeatureIngestionService', () => {
         callOrder.push('delete');
       });
 
+      const deleteRelationshipsStub = sinon
+        .stub(SubmissionRepository.prototype, 'deleteSubmissionFeatureRelationships')
+        .callsFake(async () => {
+          callOrder.push('deleteRelationships');
+        });
+
       const insertStub = sinon
         .stub(SubmissionRepository.prototype, 'insertSubmissionFeatureRecord')
         .callsFake(async () => {
@@ -1059,14 +1074,89 @@ describe('FeatureIngestionService', () => {
         });
 
       sinon.stub(SubmissionRepository.prototype, 'updateSubmissionFeatureParent').resolves();
+      sinon.stub(SubmissionRepository.prototype, 'insertSubmissionFeatureRelationships').resolves();
 
       const features: IFlattenedBlock[] = [createValidFeature()];
 
       await service.ingestFeatures(1, features);
 
       expect(callOrder[0]).to.equal('delete');
-      expect(callOrder[1]).to.equal('insert');
-      expect(deleteStub).to.have.been.calledBefore(insertStub);
+      expect(callOrder[1]).to.equal('deleteRelationships');
+      expect(callOrder[2]).to.equal('insert');
+      expect(deleteStub).to.have.been.calledOnceWith(1);
+      expect(deleteRelationshipsStub).to.have.been.calledOnceWith(1);
+      expect(insertStub).to.have.been.calledOnce;
+    });
+
+    it('should not call insertSubmissionFeatureRelationships when all features have empty content', async () => {
+      const mockDBConnection = getMockDBConnection();
+      const service = new FeatureIngestionService(mockDBConnection);
+
+      sinon
+        .stub(ValidationRepository.prototype, 'getFeatureTypeWithProperties')
+        .resolves(mockFeatureTypeWithProperties);
+
+      sinon.stub(SubmissionRepository.prototype, 'deleteSubmissionFeatures').resolves();
+      sinon.stub(SubmissionRepository.prototype, 'deleteSubmissionFeatureRelationships').resolves();
+
+      const insertStub = sinon
+        .stub(SubmissionRepository.prototype, 'insertSubmissionFeatureRecord')
+        .resolves({ submission_feature_id: 1 });
+
+      sinon.stub(SubmissionRepository.prototype, 'updateSubmissionFeatureParent').resolves();
+
+      const insertRelationshipsStub = sinon
+        .stub(SubmissionRepository.prototype, 'insertSubmissionFeatureRelationships')
+        .resolves();
+
+      const features: IFlattenedBlock[] = [
+        createValidFeature({ id: 'uuid-1', content: [], parent: null }),
+        createValidFeature({ id: 'uuid-2', content: [], parent: 'uuid-1' })
+      ];
+
+      await service.ingestFeatures(1, features);
+
+      expect(insertStub).to.have.been.calledTwice;
+      expect(insertRelationshipsStub).to.not.have.been.called;
+    });
+
+    it('should insert relationship rows for parent with multiple children', async () => {
+      const mockDBConnection = getMockDBConnection();
+      const service = new FeatureIngestionService(mockDBConnection);
+
+      sinon
+        .stub(ValidationRepository.prototype, 'getFeatureTypeWithProperties')
+        .resolves(mockFeatureTypeWithProperties);
+
+      sinon.stub(SubmissionRepository.prototype, 'deleteSubmissionFeatures').resolves();
+      sinon.stub(SubmissionRepository.prototype, 'deleteSubmissionFeatureRelationships').resolves();
+
+      const insertStub = sinon.stub(SubmissionRepository.prototype, 'insertSubmissionFeatureRecord');
+      insertStub.onFirstCall().resolves({ submission_feature_id: 10 });
+      insertStub.onSecondCall().resolves({ submission_feature_id: 20 });
+      insertStub.onThirdCall().resolves({ submission_feature_id: 30 });
+      insertStub.onCall(3).resolves({ submission_feature_id: 40 });
+
+      sinon.stub(SubmissionRepository.prototype, 'updateSubmissionFeatureParent').resolves();
+
+      const insertRelationshipsStub = sinon
+        .stub(SubmissionRepository.prototype, 'insertSubmissionFeatureRelationships')
+        .resolves();
+
+      const features: IFlattenedBlock[] = [
+        createValidFeature({ id: 'parent', parent: null, content: ['child-1', 'child-2', 'child-3'] }),
+        createValidFeature({ id: 'child-1', parent: 'parent', content: [] }),
+        createValidFeature({ id: 'child-2', parent: 'parent', content: [] }),
+        createValidFeature({ id: 'child-3', parent: 'parent', content: [] })
+      ];
+
+      await service.ingestFeatures(1, features);
+
+      expect(insertRelationshipsStub).to.have.been.calledOnceWith([
+        { source_feature_id: 10, target_feature_id: 20 },
+        { source_feature_id: 10, target_feature_id: 30 },
+        { source_feature_id: 10, target_feature_id: 40 }
+      ]);
     });
 
     it('should insert all features before updating any parent references', async () => {