feat: fail records with circular dependencies before deployment starts

Author: Codeneos

packages/vlocity-deploy/src/__tests__/datapackDeployment.test.ts

@@ -214,8 +214,8 @@ describe('DatapackDeployment', () => {
         });
     });
 
-    describe('isCircularDependencies', () => {
-        it('should return true when circular dependencies (A->B->A) exist', () => {
+    describe('hasCircularDependencies', () => {
+        it('should return path when circular dependencies (A->B->A) exist', () => {
             // Arrange
             const deployment = container.create(DatapackDeployment);
             const recordA = mockDatapackRecord( { sourceKey: 'A', datapackKey: 'A' });	
@@ -227,10 +227,12 @@ describe('DatapackDeployment', () => {
             deployment.add(recordA, recordB);
 
             // Act
-            const result = deployment['isCircularDependencies'](recordA, recordB);
+            const result1 = deployment['hasCircularDependencies'](recordA);
+            const result2 = deployment['hasCircularDependencies'](recordB);
 
             // Assert
-            expect(result).toBe(true);
+            expect(result1).toStrictEqual([ 'A', 'B', 'A' ]);	
+            expect(result2).toStrictEqual([ 'B', 'A', 'B' ]);
         });
         it('should return true when a deep circular dependencies (A->B->C->A) exist', () => {
             // Arrange
@@ -246,10 +248,10 @@ describe('DatapackDeployment', () => {
             deployment.add(recordA, recordB, recordC);
 
             // Act
-            const result = deployment['isCircularDependencies'](recordA, recordB);
+            const result = deployment['hasCircularDependencies'](recordA);
 
             // Assert
-            expect(result).toBe(true);
+            expect(result).toStrictEqual([ 'A', 'C', 'B', 'A' ]);	
         });
     });
 });

packages/vlocity-deploy/src/datapackDeployment.ts

@@ -356,6 +356,10 @@ export class DatapackDeployment extends AsyncEventEmitter<DatapackDeploymentEven
             if (this.options.strictOrder && isExternalDependency) {
                 const dependencyStatus = this.getDatapackStatus(dependentRecord.datapackKey);
                 if (dependencyStatus !== undefined && dependencyStatus < DeploymentStatus.Deployed) {
+                    if (this.isCircularDatapackDependency(record.datapackKey, dependentRecord.datapackKey)) {
+                        this.reportWarning(record, `Circular datapack dependency: ${record.datapackKey}->${dependentRecord.datapackKey}->${record.datapackKey}`);
+                        continue;
+                    }
                     return true;
                 }
             }
@@ -372,14 +376,44 @@ export class DatapackDeployment extends AsyncEventEmitter<DatapackDeploymentEven
         }
     }
 
+    /**
+     * Checks if there is a circular dependency between two datapacks.
+     * @param datapackKeyA - The key of the first datapack.
+     * @param datapackKeyB - The key of the second datapack.
+     * @returns True if there is a circular dependency, false otherwise.
+     */
+    private isCircularDatapackDependency(datapackKeyA: string, datapackKeyB: string, visited = new Set<string>()): boolean {
+        if (visited.has(datapackKeyB)) {
+            // Prevent a circular dependency check from going into an infinite loop
+            return false;
+        } else {
+            visited.add(datapackKeyB);
+        }
+        
+        for(const record of this.getRecords(datapackKeyB)) {
+            for (const dependency of record.getDependencies()) {
+                const dependentRecord = this.records.get(dependency.VlocityMatchingRecordSourceKey ?? dependency.VlocityLookupRecordSourceKey);
+                if (!dependentRecord || dependentRecord.datapackKey === datapackKeyB) {
+                    continue;
+                }
+                if (dependentRecord.datapackKey === datapackKeyA) {
+                    return true;
+                } else if (this.isCircularDatapackDependency(datapackKeyA, dependentRecord.datapackKey, visited)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
     private hasCircularDependencies(record: DatapackDeploymentRecord, graph = Array<string>()): Array<string> | false {
         if (!graph.length) {
             graph.push(record.sourceKey);
         }
 
         for(const key of record.getDependencySourceKeys()) {
             if (graph.includes(key)) {
-                return graph;
+                return [...graph, key];
             }
 
             const depedency = this.records.get(key);