Merge pull request #738 from PROCEED-Labs/fix-editable-version-changes-check

Fix: Changes in Latest Version Check

Author: Zayn-Javed

src/management-system-v2/app/(dashboard)/[environmentId]/(automation)/executions/deployments-view.tsx

@@ -9,13 +9,13 @@ import DeploymentsList from './deployments-list';
 import { Folder } from '@/lib/data/folder-schema';
 import { Process, ProcessMetadata } from '@/lib/data/process-schema';
 import { useEnvironment } from '@/components/auth-can';
-import { processHasChangesSinceLastVersion } from '@/lib/data/processes';
+import { processUnchangedFromBasedOnVersion } from '@/lib/data/processes';
 import type { DeployedProcessInfo } from '@/lib/engines/deployment';
 import { useRouter } from 'next/navigation';
 import { deployProcess as serverDeployProcess } from '@/lib/engines/server-actions';
 import { wrapServerCall } from '@/lib/wrap-server-call';
 import { SpaceEngine } from '@/lib/engines/machines';
-import { userError } from '@/lib/user-error';
+import { isUserErrorResponse, userError } from '@/lib/user-error';
 import { removeDeployment as serverRemoveDeployment } from '@/lib/engines/server-actions';
 import { useQueryClient } from '@tanstack/react-query';
 
@@ -58,22 +58,31 @@ const DeploymentsView = ({
     startCheckingProcessVersion(async () => {
       wrapServerCall({
         fn: async () => {
-          const processChangedSinceLastVersion = await processHasChangesSinceLastVersion(
+          const unchangedVersion = await processUnchangedFromBasedOnVersion(
             process.id,
             space.spaceId,
           );
-          if (typeof processChangedSinceLastVersion === 'object')
-            return processChangedSinceLastVersion;
+          if (isUserErrorResponse(unchangedVersion)) {
+            return unchangedVersion;
+          }
 
-          let latestVersion = process.versions[0];
-          for (const version of process.versions)
-            if (+version.createdOn > +latestVersion.createdOn) latestVersion = version;
+          let versionToUse = unchangedVersion;
 
-          if (!latestVersion) throw userError('Process has no versions').error;
+          if (!versionToUse) {
+            let [latestVersion, ...rest] = process.versions;
+
+            for (const version of rest) {
+              if (+version.createdOn > +latestVersion.createdOn) latestVersion = version;
+            }
+
+            versionToUse = latestVersion.id;
+          }
+
+          if (!versionToUse) throw userError('Process has no versions').error;
 
           const res = await serverDeployProcess(
             process.id,
-            latestVersion.id,
+            versionToUse,
             space.spaceId,
             'dynamic',
             forceEngine,

src/management-system-v2/lib/data/processes.tsx

@@ -569,16 +569,23 @@ export const copyProcesses = async (
   return copiedProcesses;
 };
 
-// TODO: fix: this function doesn't work yet
-export const processHasChangesSinceLastVersion = async (processId: string, spaceId: string) => {
+/**
+ * Function that checks if a process' latest version is unchanged from the version it is based on
+ *
+ * @returns if unchanged, the version id of the based on version is returned, otherwise undefined is
+ * returned
+ **/
+export const processUnchangedFromBasedOnVersion = async (processId: string, spaceId: string) => {
   const error = await checkValidity(processId, 'view', spaceId);
   if (error) return error;
 
   const process = await _getProcess(processId, true);
   if (!process) return userError('Process not found', UserErrorType.NotFoundError);
 
+  if (!process.versions.length) return;
+
   const bpmnObj = await toBpmnObject(process.bpmn!);
-  const { versionBasedOn, versionCreatedOn } = await getDefinitionsVersionInformation(bpmnObj);
+  const { versionBasedOn } = await getDefinitionsVersionInformation(bpmnObj);
 
   const versionedBpmn = await toBpmnXml(bpmnObj);
 
@@ -589,7 +596,8 @@ export const processHasChangesSinceLastVersion = async (processId: string, space
       : undefined;
 
   const versionsAreEqual = basedOnBPMN && (await areVersionsEqual(versionedBpmn, basedOnBPMN));
-  return !versionsAreEqual;
+
+  if (versionsAreEqual) return versionBasedOn;
 };
 
 export const createVersion = async (

src/management-system-v2/lib/helpers/processVersioning.ts

@@ -11,6 +11,7 @@ import {
   setScriptTaskData,
   getStartFormFileNameMapping,
   setStartFormFileName,
+  getDefinitionsId,
 } from '@proceed/bpmn-helper';
 import { asyncForEach } from './javascriptHelpers';
 
@@ -36,39 +37,57 @@ const { diff } = require('bpmn-js-differ');
 // should be refactored to reflect the fact this runs on the server now.
 
 export async function areVersionsEqual(bpmn: string, otherBpmn: string) {
-  const bpmnObj = await toBpmnObject(bpmn);
-  const otherBpmnObj = await toBpmnObject(otherBpmn);
+  // compare the bpmn of both versions excluding the differences that would come from one being
+  // versioned and the other not being versioned
+  const unversionedOther = await convertToEditableBpmn(otherBpmn);
 
-  const {
-    versionId,
-    name: versionName,
-    description: versionDescription,
-    versionBasedOn,
-    versionCreatedOn,
-  } = await getDefinitionsVersionInformation(otherBpmnObj);
-
-  if (versionId) {
-    // check if the two bpmns were the same if they had the same version information
-    await setDefinitionsVersionInformation(bpmnObj, {
-      versionId,
-      versionName,
-      versionDescription,
-      versionBasedOn,
-      versionCreatedOn,
-    });
+  const bpmnObj = await toBpmnObject(bpmn);
+  const unversionedOtherObj = await toBpmnObject(unversionedOther.bpmn);
+
+  // compare the two bpmns in a way that is not affected by the ordering of elements in the text
+  // file
+  const changes = diff(unversionedOtherObj, bpmnObj);
+  const hasChanges =
+    Object.keys(changes._changed).length ||
+    Object.keys(changes._removed).length ||
+    Object.keys(changes._added).length ||
+    Object.keys(changes._layoutChanged).length;
+
+  if (hasChanges) return false;
+
+  const definitionsId = await getDefinitionsId(bpmnObj);
+
+  // compare the assets used in the bpmns
+  // (we expect that the "same" asset names are referenced since the comparison above would find differences otherwise)
+
+  // compare start forms
+  for (const [versioned, unversioned] of Object.entries(
+    unversionedOther.changedStartFormTaskFileNames,
+  )) {
+    const versionedHtmlForm = await getHtmlForm(definitionsId, versioned);
+    const unversionedHtmlForm = await getHtmlForm(definitionsId, unversioned);
+    if (versionedHtmlForm !== unversionedHtmlForm) return false;
+  }
 
-    // compare the two bpmns
-    const changes = diff(otherBpmnObj, bpmnObj);
-    const hasChanges =
-      Object.keys(changes._changed).length ||
-      Object.keys(changes._removed).length ||
-      Object.keys(changes._added).length ||
-      Object.keys(changes._layoutChanged).length;
+  // compare user tasks
+  for (const [versioned, unversioned] of Object.entries(
+    unversionedOther.changedUserTaskFileNames,
+  )) {
+    const versionedHtmlForm = await getHtmlForm(definitionsId, versioned);
+    const unversionedHtmlForm = await getHtmlForm(definitionsId, unversioned);
+    if (versionedHtmlForm !== unversionedHtmlForm) return false;
+  }
 
-    return !hasChanges;
+  // compare script tasks
+  for (const [versioned, unversioned] of Object.entries(
+    unversionedOther.changedScriptTaskFileNames,
+  )) {
+    const versionedScript = await getProcessScriptTaskScript(definitionsId, versioned + '.js');
+    const unversionedScript = await getProcessScriptTaskScript(definitionsId, unversioned + '.js');
+    if (versionedScript !== unversionedScript) return false;
   }
 
-  return false;
+  return true;
 }
 
 export async function convertToEditableBpmn(bpmn: string) {