Fix issues discovered by ermrestjs vite branch (#2628)

Author: RFSH

.github/workflows/e2e.yml

@@ -138,18 +138,6 @@ jobs:
       - name: Restart apache
         run: |
           sudo service apache2 restart
-      - name: Run all features test spec
-        id: test-all-features
-        continue-on-error: true
-        run: |
-          cd chaise
-          make testallfeatures
-      - name: Run all features confirmation test spec
-        id: test-all-features-confirmation
-        continue-on-error: true
-        run: |
-          cd chaise
-          make testallfeaturesconfirmation
       - name: Run default config test spec
         id: test-default-config
         continue-on-error: true
@@ -162,18 +150,30 @@ jobs:
         run: |
           cd chaise
           make testdeleteprohibited
-      - name: Check on all features test spec
-        if: always() && steps.test-all-features.outcome != 'success'
-        run: exit 1
-      - name: Check on all features confirmation test spec
-        if: always() && steps.test-all-features-confirmation.outcome != 'success'
-        run: exit 1
+      - name: Run all features confirmation test spec
+        id: test-all-features-confirmation
+        continue-on-error: true
+        run: |
+          cd chaise
+          make testallfeaturesconfirmation
+      - name: Run all features test spec
+        id: test-all-features
+        continue-on-error: true
+        run: |
+          cd chaise
+          make testallfeatures
       - name: Check on default config test spec
         if: always() && steps.test-default-config.outcome != 'success'
         run: exit 1
       - name: Check on delete prohibited test spec
         if: always() && steps.test-delete-prohibited.outcome != 'success'
         run: exit 1
+      - name: Check on all features confirmation test spec
+        if: always() && steps.test-all-features-confirmation.outcome != 'success'
+        run: exit 1
+      - name: Check on all features test spec
+        if: always() && steps.test-all-features.outcome != 'success'
+        run: exit 1
       - uses: actions/upload-artifact@v4
         if: always()
         with:

Makefile

@@ -27,10 +27,6 @@ CHAISE_BASE_PATH:=$(WEB_URL_ROOT)$(CHAISE_REL_PATH)
 ERMRESTJS_BASE_PATH:=$(WEB_URL_ROOT)$(ERMRESTJS_REL_PATH)
 OSD_VIEWER_BASE_PATH:=$(WEB_URL_ROOT)$(OSD_VIEWER_REL_PATH)
 
-# ERMrestjs dependencies
-ERMRESTJS_DEPS=ermrest.vendor.min.js \
-	ermrest.min.js
-
 # Project name
 PROJ=chaise
 

package-lock.json

@@ -1,7 +1,7 @@
 {
   "name": "@isrd-isi-edu/chaise",
   "description": "An adaptive User Interface for ERMrest data sources",
-  "version": "0.0.25",
+  "version": "0.0.26",
   "license": "Apache-2.0",
   "engines": {
     "node": ">= 20.0.0",

package.json

@@ -199,10 +199,11 @@ const UploadProgressModal = ({ rows, linkedData, show, onSuccess, onCancel }: Up
     setIsUpload(false);
     uploadRowsRef.current.forEach((row: UploadFileObject[]) => {
       row.forEach((item: UploadFileObject) => {
-        item.hatracObj.calculateChecksum(item.row, item.linkedData).then(
-          (url: string) => onChecksumCompleted(item, url),
-          onError,
-          (uploaded: number) => onChecksumProgressChanged(item, uploaded));
+        item.hatracObj.calculateChecksum(
+          item.row,
+          item.linkedData,
+          (uploaded: number) => onChecksumProgressChanged(item, uploaded)
+        ).then((url: string) => onChecksumCompleted(item, url)).catch(onError);
       });
     });
   };
@@ -286,10 +287,10 @@ const UploadProgressModal = ({ rows, linkedData, show, onSuccess, onCancel }: Up
     let startChunkIdx = 0;
     if (item.partialUpload) startChunkIdx = lastContiguousChunkRef.current?.[item.uploadKey].lastChunkIdx + 1;
 
-    item.hatracObj.start(startChunkIdx).then(
-      () => onUploadCompleted(item),
-      onError,
-      (size: number) => onProgressChanged(item, size));
+    item.hatracObj.start(
+      startChunkIdx,
+      (size: number) => onProgressChanged(item, size)
+    ).then(() => onUploadCompleted(item)).catch(onError)
   };
 
   // Complete upload jobs one by one

src/components/modals/upload-progress-modal.tsx

@@ -6,9 +6,6 @@ import {
   RecordsetProviderUpdateMainEntity
 } from '@isrd-isi-edu/chaise/src/models/recordset'
 
-// utils
-import { isObjectAndNotNull } from '@isrd-isi-edu/chaise/src/utils/type-utils';
-
 export interface RecordRelatedModelRecordsetProps {
   page: any,
   isLoading: boolean,
@@ -21,12 +18,27 @@ export interface RecordRelatedModel {
   isInline: boolean,
   isPureBinary: boolean,
   initialReference: any,
+  /**
+   * whether we're showing the tabular view or custom view
+   */
   isTableDisplay: boolean,
-  // this indicates that the tableMarkdownContent has been initialized:
-  // we should not show the related table before initialzing the tableMarkdownContent
+  /**
+   * this indicates that the tableMarkdownContent has been initialized:
+   * we should not show the related table before initialzing the tableMarkdownContent
+   */
   tableMarkdownContentInitialized: boolean,
-  tableMarkdownContent: string|null, // TODO
+  /**
+   * the "custom display" content.
+   */
+  tableMarkdownContent: string|null,
+  /**
+   * information that the recordset provider shares with record page
+   * (has page, isLoading, etc)
+   */
   recordsetState: RecordRelatedModelRecordsetProps,
+  /**
+   * The props that will be passed to the recordset provider for the related model
+   */
   recordsetProps: {
     initialPageLimit: number,
     config: RecordsetConfig,
@@ -54,11 +66,19 @@ export interface RecordColumnModel {
 
 export interface RecordRelatedRequestModel {
   index: number,
-  // whether we should do the waitfor logic:
+  /**
+   * whether we should do the waitfor logic:
+   */
   hasWaitFor: boolean,
-  // this indicates that we got the waitfor data:
-  // only if w got the waitfor data, and the main data we can popuplate the tableMarkdownContent value
+  /**
+   * this indicates that we got the waitfor data:
+   * only if w got the waitfor data, and the main data we can popuplate the tableMarkdownContent value
+   */
   waitForDataLoaded: boolean,
+  /**
+   * to avoid computing this multiple times.
+   */
+  tableMarkdownContentProcessed: boolean,
   registered: boolean,
   updateMainEntity: RecordsetProviderUpdateMainEntity,
   fetchSecondaryRequests: RecordsetProviderFetchSecondaryRequests,

src/models/record.ts

@@ -290,6 +290,7 @@ export default function RecordProvider({
       if (m.hasWaitFor) {
         m.waitForDataLoaded = false;
       }
+      m.tableMarkdownContentProcessed = false;
     });
 
     // related table
@@ -300,6 +301,7 @@ export default function RecordProvider({
       if (m.hasWaitFor) {
         m.waitForDataLoaded = false;
       }
+      m.tableMarkdownContentProcessed = false;
     });
 
     // update the cause list
@@ -369,9 +371,14 @@ export default function RecordProvider({
   }
 
   // -------------------------- flow control function ---------------------- //
-  const printDebugMessage = (message: string, counter?: number): void => {
+  const printDebugMessage = (message: string, relatedModel?: RecordRelatedModel, counter?: number): void => {
     counter = typeof counter !== 'number' ? flowControl.current.queue.counter : counter;
-    $log.debug(`${Date.now()}, ${counter}: ${message}`);
+    let dm = `${Date.now()}, ${counter}: `;
+    if (relatedModel) {
+      dm += `${relatedModel.isInline ? 'inline' : 'related'}(index=${relatedModel.index}), `;
+    }
+    dm += `${message}`;
+    $log.debug(dm);
   };
 
   /**
@@ -652,6 +659,7 @@ export default function RecordProvider({
           // this indicates that we got the waitfor data:
           // only if w got the waitfor data, and the main data we can popuplate the tableMarkdownContent value
           waitForDataLoaded: !col.hasWaitFor,
+          tableMarkdownContentProcessed: false,
           updateMainEntity: () => { throw new Error('function not registered') },
           fetchSecondaryRequests: () => { throw new Error('function not registered') },
           addUpdateCauses: () => { throw new Error('function not registered') },
@@ -679,6 +687,7 @@ export default function RecordProvider({
         index,
         hasWaitFor: ref.display.sourceHasWaitFor,
         waitForDataLoaded: false,
+        tableMarkdownContentProcessed: false,
         updateMainEntity: () => { throw new Error('function not registered') },
         fetchSecondaryRequests: () => { throw new Error('function not registered') },
         addUpdateCauses: () => { throw new Error('function not registered') },
@@ -708,10 +717,30 @@ export default function RecordProvider({
    * @param values the updated values
    */
   const updateRelatedRecordsetState = (index: number, isInline: boolean, values: RecordRelatedModelRecordsetProps) => {
+    printDebugMessage(`${isInline ? 'inline' : 'related'}(index=${index}), updating recordset state isLoading: ${values.isLoading}`);
+    const updatedValues: { [key: string]: any } = { recordsetState: values };
+
+    /**
+     * There might be a delay between recieving the data and updating the state. If the delay is long enough that the
+     * waitForDataLoaded is set to true but the recordsetState still is not updated, the attachPseudoColumnValue might not
+     * be able to process the markdown content. So the following checks if that the case and if so, it would compute the
+     * markdown content.
+     */
+    const rm = isInline ? flowControl.current.inlineRelatedRequestModels[index] : flowControl.current.relatedRequestModels[index];
+    const m = isInline ? columnModels[index].relatedModel : relatedModels[index];
+    const hasMainData = values.page && !values.isLoading;
+    const hasWaitForData = !rm.hasWaitFor || rm.waitForDataLoaded;
+    if (!rm.tableMarkdownContentProcessed && hasMainData && hasWaitForData) {
+      printDebugMessage('updating markdown content in updateRelatedRecordsetState', m);
+      rm.tableMarkdownContentProcessed = true;
+      updatedValues.tableMarkdownContentInitialized = true;
+      updatedValues.tableMarkdownContent = values.page.getContent(flowControl.current.templateVariables);
+    }
+
     if (isInline) {
-      setColumnModelsRelatedModelByIndex(index, { recordsetState: values });
+      setColumnModelsRelatedModelByIndex(index, updatedValues);
     } else {
-      setRelatedModelsByIndex(index, { recordsetState: values });
+      setRelatedModelsByIndex(index, updatedValues);
     }
   };
 
@@ -754,13 +783,19 @@ export default function RecordProvider({
       reqModel.processed = !res.success;
 
       const rm = isInline ? flowControl.current.inlineRelatedRequestModels[index] : flowControl.current.relatedRequestModels[index];
+      const m = isInline ? columnModels[index].relatedModel : relatedModels[index];
 
       /*
       * the returned `res` boolean indicates whether we should consider this response final or not.
       * it doesn't necessarily mean that the response was successful, so we should not use the page blindly.
       * If the request errored out (timeout or other types of error) page will be undefined.
       */
-      if (res.success && res.page && (!rm.hasWaitFor || rm.waitForDataLoaded)) {
+     const hasMainData = res.success && res.page;
+     const hasWaitForData = !rm.hasWaitFor || rm.waitForDataLoaded;
+      if (hasMainData && hasWaitForData) {
+        printDebugMessage('updating markdown content in afterUpdateRelatedEntity', m);
+
+        rm.tableMarkdownContentProcessed = true;
         const updatedValues = {
           tableMarkdownContentInitialized: true,
           tableMarkdownContent: res.page.getContent(flowControl.current.templateVariables)
@@ -770,6 +805,8 @@ export default function RecordProvider({
         } else {
           setRelatedModelsByIndex(index, updatedValues);
         }
+      } else {;
+        printDebugMessage(`unable to update markdown content, main:${hasMainData}, waitFor: ${hasWaitForData}`, m);
       }
     };
   };
@@ -810,12 +847,28 @@ export default function RecordProvider({
         cb = activeListModel.column.getAggregatedValue(pageRef.current, logObj);
       }
 
+      const dependentSummary = activeListModel.objects.map((obj: any) => {
+        let objType;
+        if (obj.column) {
+          objType = 'column';
+        } else if (obj.inline) {
+          objType = 'inline';
+        } else {
+          objType = 'related';
+        }
+        return `${objType}(index=${obj.index})`;
+      });
+
+      const description = `(${activeListModel.entityset ? 'entityset' : 'aggregate'}) for: ${dependentSummary.join(', ')}`;
+      printDebugMessage(`fetching 2nd req ${description}`);
       cb.then(function (values: any) {
         if (flowControl.current.queue.counter !== current) {
           resolve(false);
           return;
         }
 
+        printDebugMessage(`successful 2nd req fetch ${description}`);
+
         // remove the column error (they might retry)
         const errroIndexes: any = {};
         activeListModel.objects.forEach(function (obj: any) {
@@ -876,6 +929,8 @@ export default function RecordProvider({
           return;
         }
 
+        printDebugMessage(`failed 2nd req ${description}`);
+
         const errorIndexes: any = {};
         activeListModel.objects.forEach(function (obj: any) {
           if (obj.column || obj.inline) {
@@ -959,6 +1014,7 @@ export default function RecordProvider({
           reqModel = flowControl.current.inlineRelatedRequestModels[obj.index];
         }
         const hasAll = ref.display.sourceWaitFor.every(hasColumnData);
+        printDebugMessage(`hasAll: ${hasAll}`, obj.related ? relatedModelsRef.current[obj.index] : columnModelsRef.current[obj.index].relatedModel);
         if (!hasAll) return;
 
         // in case the main request was slower, this will just signal so the other
@@ -974,6 +1030,8 @@ export default function RecordProvider({
       }
     });
 
+    printDebugMessage(`attachPseudoColumnValue, doneInlines: ${Object.keys(doneInlines)}, doneRelated: ${Object.keys(doneRelated)}`);
+
     // set the values
     setRecordValues((prevValues: any) => (
       prevValues.map((val: any, index: number) => {
@@ -995,10 +1053,15 @@ export default function RecordProvider({
           // otherwise we should just wait for the related/inline table data to get back to popuplate the tableMarkdownContent
           let mdProps: { tableMarkdownContentInitialized: boolean, tableMarkdownContent: string | null } | object = {};
           if (val.relatedModel.recordsetState.page && !val.relatedModel.recordsetState.isLoading) {
+            printDebugMessage('updating markdown content in attachPseudoColumnValue', val.relatedModel);
+            const rm = flowControl.current.inlineRelatedRequestModels[index];
+            rm.tableMarkdownContentProcessed = true;
             mdProps = {
               tableMarkdownContentInitialized: true,
               tableMarkdownContent: val.relatedModel.recordsetState.page.getContent(flowControl.current.templateVariables),
             }
+          }  else {
+            printDebugMessage('unable to update markdown content since main page is still not loaded', val.relatedModel);
           }
           return { ...val, isLoading: false, relatedModel: { ...val.relatedModel, ...mdProps } };
         }
@@ -1013,11 +1076,16 @@ export default function RecordProvider({
           // if the page data is already fetched, we can just popuplate the tableMarkdownContent value.
           // otherwise we should just wait for the related/inline table data to get back to popuplate the tableMarkdownContent
           if (val.recordsetState.page && !val.recordsetState.isLoading) {
+            printDebugMessage('updating markdown content in attachPseudoColumnValue', val);
+            const rm = flowControl.current.relatedRequestModels[index];
+            rm.tableMarkdownContentProcessed = true;
             return {
               ...val,
               tableMarkdownContentInitialized: true,
               tableMarkdownContent: val.recordsetState.page.getContent(flowControl.current.templateVariables),
             }
+          } else {
+            printDebugMessage('unable to update markdown content since main page is still not loaded', val);
           }
         }
         return val;