Bump org.apache.poi:poi-ooxml

Bumps the maven group with 1 update in the /qqq-backend-core directory: org.apache.poi:poi-ooxml.


Updates `org.apache.poi:poi-ooxml` from 5.2.5 to 5.4.0

---
updated-dependencies:
- dependency-name: org.apache.poi:poi-ooxml
  dependency-version: 5.4.0
  dependency-type: direct:production
  dependency-group: maven
...

Signed-off-by: dependabot[bot] <support@github.com>

.circleci/config.yml

@@ -48,11 +48,7 @@ commands:
       - run:
           name: Run Maven Verify
           command: |
-            mvn -s .circleci/mvn-settings.xml -T4 verify | tee mvn-verify.log
-      - store_artifacts:
-          name: Full Maven Verify Log
-          path: mvn-verify.log
-          destination: mvn-verify
+            mvn -s .circleci/mvn-settings.xml -T4 verify
       - store_jacoco_site:
           module: qqq-backend-core
       - store_jacoco_site:

qqq-backend-core/pom.xml

@@ -119,7 +119,7 @@
       <dependency>
          <groupId>org.apache.poi</groupId>
          <artifactId>poi-ooxml</artifactId>
-         <version>5.2.5</version>
+         <version>5.4.0</version>
       </dependency>
 
       <!-- adding to help FastExcel -->

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/templates/ConvertHtmlToPdfAction.java

@@ -35,7 +35,6 @@ import com.openhtmltopdf.pdfboxout.PdfBoxFontResolver;
 import com.openhtmltopdf.pdfboxout.PdfBoxRenderer;
 import com.openhtmltopdf.pdfboxout.PdfRendererBuilder;
 import org.jsoup.Jsoup;
-import org.jsoup.helper.W3CDom;
 import org.jsoup.nodes.Document;
 
 
@@ -68,7 +67,6 @@ public class ConvertHtmlToPdfAction extends AbstractQActionFunction<ConvertHtmlT
          //////////////////////////////////////////////////////////////////
          Document document = Jsoup.parse(input.getHtml());
          document.outputSettings().syntax(Document.OutputSettings.Syntax.xml);
-         org.w3c.dom.Document w3cDoc = new W3CDom().fromJsoup(document);
 
          //////////////////////////////
          // convert the XHTML to PDF //
@@ -76,7 +74,7 @@ public class ConvertHtmlToPdfAction extends AbstractQActionFunction<ConvertHtmlT
          PdfRendererBuilder builder = new PdfRendererBuilder();
          builder.toStream(input.getOutputStream());
          builder.useFastMode();
-         builder.withW3cDocument(w3cDoc, input.getBasePath() == null ? "./" : input.getBasePath().toUri().toString());
+         builder.withHtmlContent(document.html(), input.getBasePath() == null ? "./" : input.getBasePath().toUri().toString());
 
          try(PdfBoxRenderer pdfBoxRenderer = builder.buildPdfRenderer())
          {

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/values/BasicCustomPossibleValueProvider.java

@@ -1,91 +0,0 @@
-/*
- * QQQ - Low-code Application Framework for Engineers.
- * Copyright (C) 2021-2025.  Kingsrook, LLC
- * 651 N Broad St Ste 205 # 6917 | Middletown DE 19709 | United States
- * contact@kingsrook.com
- * https://github.com/Kingsrook/
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as
- * published by the Free Software Foundation, either version 3 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.kingsrook.qqq.backend.core.actions.values;
-
-
-import java.io.Serializable;
-import java.util.ArrayList;
-import java.util.List;
-import com.kingsrook.qqq.backend.core.exceptions.QException;
-import com.kingsrook.qqq.backend.core.model.actions.values.SearchPossibleValueSourceInput;
-import com.kingsrook.qqq.backend.core.model.metadata.possiblevalues.QPossibleValue;
-
-
-/*******************************************************************************
- ** Basic implementation of a possible value provider, for where there's a limited
- ** set of possible source objects - so you just have to define how to make one
- ** PV from a source object, how to list all of the source objects, and how to
- ** look up a PV from an id.
- *******************************************************************************/
-public abstract class BasicCustomPossibleValueProvider<S, ID extends Serializable> implements QCustomPossibleValueProvider<ID>
-{
-
-   /***************************************************************************
-    **
-    ***************************************************************************/
-   protected abstract QPossibleValue<ID> makePossibleValue(S sourceObject);
-
-   /***************************************************************************
-    **
-    ***************************************************************************/
-   protected abstract S getSourceObject(Serializable id);
-
-   /***************************************************************************
-    **
-    ***************************************************************************/
-   protected abstract List<S> getAllSourceObjects();
-
-
-
-   /***************************************************************************
-    **
-    ***************************************************************************/
-   @Override
-   public QPossibleValue<ID> getPossibleValue(Serializable idValue)
-   {
-      S sourceObject = getSourceObject(idValue);
-      if(sourceObject == null)
-      {
-         return (null);
-      }
-
-      return makePossibleValue(sourceObject);
-   }
-
-
-
-   /***************************************************************************
-    **
-    ***************************************************************************/
-   @Override
-   public List<QPossibleValue<ID>> search(SearchPossibleValueSourceInput input) throws QException
-   {
-      List<QPossibleValue<ID>> allPossibleValues = new ArrayList<>();
-      List<S>                  allSourceObjects  = getAllSourceObjects();
-      for(S sourceObject : allSourceObjects)
-      {
-         allPossibleValues.add(makePossibleValue(sourceObject));
-      }
-
-      return completeCustomPVSSearch(input, allPossibleValues);
-   }
-}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/dashboard/widgets/WidgetType.java

@@ -66,7 +66,6 @@ public enum WidgetType
    // record view/edit widgets //
    //////////////////////////////
    CHILD_RECORD_LIST("childRecordList"),
-   CUSTOM_COMPONENT("customComponent"),
    DYNAMIC_FORM("dynamicForm"),
    DATA_BAG_VIEWER("dataBagViewer"),
    PIVOT_TABLE_SETUP("pivotTableSetup"),

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/metadata/tables/TablesCustomPossibleValueProvider.java

@@ -27,9 +27,11 @@ import java.util.ArrayList;
 import java.util.List;
 import com.kingsrook.qqq.backend.core.actions.permissions.PermissionCheckResult;
 import com.kingsrook.qqq.backend.core.actions.permissions.PermissionsHelper;
-import com.kingsrook.qqq.backend.core.actions.values.BasicCustomPossibleValueProvider;
+import com.kingsrook.qqq.backend.core.actions.values.QCustomPossibleValueProvider;
 import com.kingsrook.qqq.backend.core.context.QContext;
+import com.kingsrook.qqq.backend.core.exceptions.QException;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryInput;
+import com.kingsrook.qqq.backend.core.model.actions.values.SearchPossibleValueSourceInput;
 import com.kingsrook.qqq.backend.core.model.metadata.possiblevalues.QPossibleValue;
 import com.kingsrook.qqq.backend.core.utils.ValueUtils;
 
@@ -38,72 +40,50 @@ import com.kingsrook.qqq.backend.core.utils.ValueUtils;
  ** possible-value source provider for the `Tables` PVS - a list of all tables
  ** in an application/qInstance.
  *******************************************************************************/
-public class TablesCustomPossibleValueProvider extends BasicCustomPossibleValueProvider<QTableMetaData, String>
+public class TablesCustomPossibleValueProvider implements QCustomPossibleValueProvider<String>
 {
 
    /***************************************************************************
     **
     ***************************************************************************/
    @Override
-   protected QPossibleValue<String> makePossibleValue(QTableMetaData sourceObject)
+   public QPossibleValue<String> getPossibleValue(Serializable idValue)
    {
-      return (new QPossibleValue<>(sourceObject.getName(), sourceObject.getLabel()));
-   }
-
-
-
-   /***************************************************************************
-    **
-    ***************************************************************************/
-   @Override
-   protected QTableMetaData getSourceObject(Serializable id)
-   {
-      QTableMetaData table = QContext.getQInstance().getTable(ValueUtils.getValueAsString(id));
-      return isTableAllowed(table) ? table : null;
-   }
-
-
-
-   /***************************************************************************
-    **
-    ***************************************************************************/
-   @Override
-   protected List<QTableMetaData> getAllSourceObjects()
-   {
-      ArrayList<QTableMetaData> rs = new ArrayList<>();
-      for(QTableMetaData table : QContext.getQInstance().getTables().values())
+      QTableMetaData table = QContext.getQInstance().getTable(ValueUtils.getValueAsString(idValue));
+      if(table != null && !table.getIsHidden())
       {
-         if(isTableAllowed(table))
+         PermissionCheckResult permissionCheckResult = PermissionsHelper.getPermissionCheckResult(new QueryInput(table.getName()), table);
+         if(PermissionCheckResult.ALLOW.equals(permissionCheckResult))
          {
-            rs.add(table);
+            return (new QPossibleValue<>(table.getName(), table.getLabel()));
          }
       }
-      return rs;
+
+      return null;
    }
 
 
+
    /***************************************************************************
     **
     ***************************************************************************/
-   private boolean isTableAllowed(QTableMetaData table)
+   @Override
+   public List<QPossibleValue<String>> search(SearchPossibleValueSourceInput input) throws QException
    {
-      if(table == null)
+      /////////////////////////////////////////////////////////////////////////////////////
+      // build all of the possible values (note, will be filtered by user's permissions) //
+      /////////////////////////////////////////////////////////////////////////////////////
+      List<QPossibleValue<String>> allPossibleValues = new ArrayList<>();
+      for(QTableMetaData table : QContext.getQInstance().getTables().values())
       {
-         return (false);
+         QPossibleValue<String> possibleValue = getPossibleValue(table.getName());
+         if(possibleValue != null)
+         {
+            allPossibleValues.add(possibleValue);
+         }
       }
 
-      if(table.getIsHidden())
-      {
-         return (false);
-      }
-
-      PermissionCheckResult permissionCheckResult = PermissionsHelper.getPermissionCheckResult(new QueryInput(table.getName()), table);
-      if(!PermissionCheckResult.ALLOW.equals(permissionCheckResult))
-      {
-         return (false);
-      }
-
-      return (true);
+      return completeCustomPVSSearch(input, allPossibleValues);
    }
 
 }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/metadata/tables/TablesPossibleValueSourceMetaDataProvider.java

@@ -24,7 +24,6 @@ package com.kingsrook.qqq.backend.core.model.metadata.tables;
 
 import com.kingsrook.qqq.backend.core.model.metadata.QInstance;
 import com.kingsrook.qqq.backend.core.model.metadata.code.QCodeReference;
-import com.kingsrook.qqq.backend.core.model.metadata.fields.QFieldType;
 import com.kingsrook.qqq.backend.core.model.metadata.possiblevalues.PVSValueFormatAndFields;
 import com.kingsrook.qqq.backend.core.model.metadata.possiblevalues.QPossibleValueSource;
 import com.kingsrook.qqq.backend.core.model.metadata.possiblevalues.QPossibleValueSourceType;
@@ -46,7 +45,6 @@ public class TablesPossibleValueSourceMetaDataProvider
    {
       QPossibleValueSource possibleValueSource = new QPossibleValueSource()
          .withName(NAME)
-         .withIdType(QFieldType.STRING)
          .withType(QPossibleValueSourceType.CUSTOM)
          .withCustomCodeReference(new QCodeReference(TablesCustomPossibleValueProvider.class))
          .withValueFormatAndFields(PVSValueFormatAndFields.LABEL_ONLY);

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/processes/implementations/bulk/insert/BulkInsertExtractStep.java

@@ -55,6 +55,8 @@ public class BulkInsertExtractStep extends AbstractExtractStep
    @Override
    public void run(RunBackendStepInput runBackendStepInput, RunBackendStepOutput runBackendStepOutput) throws QException
    {
+      runBackendStepInput.traceMessage(BulkInsertStepUtils.getProcessTracerKeyRecordMessage(runBackendStepInput));
+
       int rowsAdded     = 0;
       int originalLimit = Objects.requireNonNullElse(getLimit(), Integer.MAX_VALUE);
 

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/processes/implementations/bulk/insert/BulkInsertLoadStep.java

@@ -41,7 +41,6 @@ import com.kingsrook.qqq.backend.core.model.metadata.fields.QFieldMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
 import com.kingsrook.qqq.backend.core.processes.implementations.etl.streamedwithfrontend.LoadViaInsertStep;
 import com.kingsrook.qqq.backend.core.processes.implementations.etl.streamedwithfrontend.ProcessSummaryProviderInterface;
-import com.kingsrook.qqq.backend.core.processes.implementations.general.ProcessSummaryWarningsAndErrorsRollup;
 import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
 
 
@@ -78,77 +77,19 @@ public class BulkInsertLoadStep extends LoadViaInsertStep implements ProcessSumm
 
       QTableMetaData table = QContext.getQInstance().getTable(runBackendStepInput.getValueString("tableName"));
 
-      /////////////////////////////////////////////////////////////////////////////////////////////
-      // the transform step builds summary lines that it predicts will insert successfully.      //
-      // but those lines don't have ids, which we'd like to have (e.g., for a process trace that //
-      // might link to the built record).  also, it's possible that there was a fail that only   //
-      // happened in the actual insert, so, basically, re-do the summary here                    //
-      /////////////////////////////////////////////////////////////////////////////////////////////
-      BulkInsertTransformStep transformStep = (BulkInsertTransformStep) getTransformStep();
-      ProcessSummaryLine      okSummary     = transformStep.okSummary;
-      okSummary.setCount(0);
-      okSummary.setPrimaryKeys(new ArrayList<>());
-
-      //////////////////////////////////////////////////////////////////////////////////////////////////////////
-      // but - since errors from the transform step don't even make it through to us here in the load step,   //
-      // do re-use the ProcessSummaryWarningsAndErrorsRollup from transform step as follows:                  //
-      // clear out its warnings - we'll completely rebuild them here (with primary keys)                      //
-      // and add new error lines, e.g., in case of errors that only happened past the validation if possible. //
-      //////////////////////////////////////////////////////////////////////////////////////////////////////////
-      ProcessSummaryWarningsAndErrorsRollup processSummaryWarningsAndErrorsRollup = transformStep.processSummaryWarningsAndErrorsRollup;
-      processSummaryWarningsAndErrorsRollup.resetWarnings();
-
       List<QRecord> insertedRecords = runBackendStepOutput.getRecords();
       for(QRecord insertedRecord : insertedRecords)
       {
-         Serializable primaryKey = insertedRecord.getValue(table.getPrimaryKeyField());
-         if(CollectionUtils.nullSafeIsEmpty(insertedRecord.getErrors()) && primaryKey != null)
+         if(CollectionUtils.nullSafeIsEmpty(insertedRecord.getErrors()))
          {
-            /////////////////////////////////////////////////////////////////////////
-            // if the record had no errors, and we have a primary key for it, then //
-            // keep track of the range of primary keys (first and last)            //
-            /////////////////////////////////////////////////////////////////////////
             if(firstInsertedPrimaryKey == null)
             {
-               firstInsertedPrimaryKey = primaryKey;
+               firstInsertedPrimaryKey = insertedRecord.getValue(table.getPrimaryKeyField());
             }
 
-            lastInsertedPrimaryKey = primaryKey;
-
-            if(!CollectionUtils.nullSafeIsEmpty(insertedRecord.getWarnings()))
-            {
-               /////////////////////////////////////////////////////////////////////////////
-               // if there were warnings on the inserted record, put it in a warning line //
-               /////////////////////////////////////////////////////////////////////////////
-               String message = insertedRecord.getWarnings().get(0).getMessage();
-               processSummaryWarningsAndErrorsRollup.addWarning(message, primaryKey);
-            }
-            else
-            {
-               ////////////////////////////////////////////////////////////////////////
-               // if no warnings for the inserted record, then put it in the OK line //
-               ////////////////////////////////////////////////////////////////////////
-               okSummary.incrementCountAndAddPrimaryKey(primaryKey);
-            }
-         }
-         else
-         {
-            //////////////////////////////////////////////////////////////////////
-            // else if there were errors or no primary key, build an error line //
-            //////////////////////////////////////////////////////////////////////
-            String message = "Failed to insert";
-            if(!CollectionUtils.nullSafeIsEmpty(insertedRecord.getErrors()))
-            {
-               //////////////////////////////////////////////////////////
-               // use the error message from the record if we have one //
-               //////////////////////////////////////////////////////////
-               message = insertedRecord.getErrors().get(0).getMessage();
-            }
-            processSummaryWarningsAndErrorsRollup.addError(message, primaryKey);
+            lastInsertedPrimaryKey = insertedRecord.getValue(table.getPrimaryKeyField());
          }
       }
-
-      okSummary.pickMessage(true);
    }
 
 

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/processes/implementations/bulk/insert/BulkInsertPrepareFileUploadStep.java

@@ -52,11 +52,6 @@ public class BulkInsertPrepareFileUploadStep implements BackendStep
    @Override
    public void run(RunBackendStepInput runBackendStepInput, RunBackendStepOutput runBackendStepOutput) throws QException
    {
-      ////////////////////////////////////////////////////////////////////////////////////////
-      // for headless-bulk load (e.g., sftp import), set up the process tracer's key record //
-      ////////////////////////////////////////////////////////////////////////////////////////
-      runBackendStepInput.traceMessage(BulkInsertStepUtils.getProcessTracerKeyRecordMessage(runBackendStepInput));
-
       ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
       // if user has come back here, clear out file (else the storageInput object that it is comes to the frontend, which isn't what we want!) //
       ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/processes/implementations/bulk/insert/BulkInsertReceiveFileMappingStep.java

@@ -46,7 +46,6 @@ import com.kingsrook.qqq.backend.core.processes.implementations.bulk.insert.mode
 import com.kingsrook.qqq.backend.core.processes.implementations.bulk.insert.model.BulkLoadProfileField;
 import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
 import com.kingsrook.qqq.backend.core.utils.JsonUtils;
-import com.kingsrook.qqq.backend.core.utils.StringUtils;
 import com.kingsrook.qqq.backend.core.utils.ValueUtils;
 import org.apache.commons.lang3.BooleanUtils;
 
@@ -78,14 +77,10 @@ public class BulkInsertReceiveFileMappingStep implements BackendStep
             //////////////////////////////////////////////////////////////////////////////
             if(savedBulkLoadProfileRecord == null)
             {
-               throw (new QUserFacingException("Did not receive a Bulk Load Profile record as input.  Unable to perform headless bulk load"));
+               throw (new QUserFacingException("Did not receive a saved bulk load profile record as input - unable to perform headless bulk load"));
             }
 
             SavedBulkLoadProfile savedBulkLoadProfile = new SavedBulkLoadProfile(savedBulkLoadProfileRecord);
-            if(!StringUtils.hasContent(savedBulkLoadProfile.getMappingJson()))
-            {
-               throw (new QUserFacingException("Bulk Load Profile record's Mapping is empty.  Unable to perform headless bulk load"));
-            }
 
             try
             {
@@ -93,7 +88,7 @@ public class BulkInsertReceiveFileMappingStep implements BackendStep
             }
             catch(Exception e)
             {
-               throw (new QUserFacingException("Error processing Bulk Load Profile record.  Unable to perform headless bulk load", e));
+               throw (new QUserFacingException("Error processing saved bulk load profile record - unable to perform headless bulk load", e));
             }
          }
          else
@@ -245,11 +240,6 @@ public class BulkInsertReceiveFileMappingStep implements BackendStep
             }
          }
       }
-      catch(QUserFacingException ufe)
-      {
-         LOG.warn("User-facing error in bulk insert receive mapping", ufe);
-         throw ufe;
-      }
       catch(Exception e)
       {
          LOG.warn("Error in bulk insert receive mapping", e);

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/processes/implementations/bulk/insert/BulkInsertTransformStep.java

@@ -75,9 +75,9 @@ import com.kingsrook.qqq.backend.core.utils.ValueUtils;
  *******************************************************************************/
 public class BulkInsertTransformStep extends AbstractTransformStep
 {
-   ProcessSummaryLine okSummary = new ProcessSummaryLine(Status.OK);
+   private ProcessSummaryLine okSummary = new ProcessSummaryLine(Status.OK);
 
-   ProcessSummaryWarningsAndErrorsRollup processSummaryWarningsAndErrorsRollup = ProcessSummaryWarningsAndErrorsRollup.build("inserted")
+   private ProcessSummaryWarningsAndErrorsRollup processSummaryWarningsAndErrorsRollup = ProcessSummaryWarningsAndErrorsRollup.build("inserted")
       .withDoReplaceSingletonCountLinesWithSuffixOnly(false);
 
    private ListingHash<String, RowValue> errorToExampleRowValueMap = new ListingHash<>();

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/processes/implementations/general/ProcessSummaryWarningsAndErrorsRollup.java

@@ -195,7 +195,7 @@ public class ProcessSummaryWarningsAndErrorsRollup
             {
                if(otherWarningsSummary == null)
                {
-                  otherWarningsSummary = buildOtherWarningsSummary();
+                  otherWarningsSummary = new ProcessSummaryLine(Status.WARNING).withMessageSuffix("records had an other warning.");
                }
                processSummaryLine = otherWarningsSummary;
             }
@@ -214,27 +214,6 @@ public class ProcessSummaryWarningsAndErrorsRollup
 
 
 
-   /***************************************************************************
-    **
-    ***************************************************************************/
-   private static ProcessSummaryLine buildOtherWarningsSummary()
-   {
-      return new ProcessSummaryLine(Status.WARNING).withMessageSuffix("records had an other warning.");
-   }
-
-
-
-   /***************************************************************************
-    **
-    ***************************************************************************/
-   public void resetWarnings()
-   {
-      warningSummaries.clear();
-      otherWarningsSummary = buildOtherWarningsSummary();
-   }
-
-
-
    /*******************************************************************************
     ** Wrapper around AlphaNumericComparator for ProcessSummaryLineInterface that
     ** extracts string messages out.

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/processes/utils/RecordLookupHelper.java

@@ -23,7 +23,6 @@ package com.kingsrook.qqq.backend.core.processes.utils;
 
 
 import java.io.Serializable;
-import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
@@ -52,14 +51,13 @@ import com.kingsrook.qqq.backend.core.utils.ValueUtils;
  *******************************************************************************/
 public class RecordLookupHelper
 {
-   private Map<String, Map<Serializable, QRecord>> recordMaps;
+   private Map<String, Map<Serializable, QRecord>> recordMaps = new HashMap<>();
 
-   private Map<String, Map<Map<String, Serializable>, QRecord>> uniqueKeyMaps;
+   private Map<String, Map<Map<String, Serializable>, QRecord>> uniqueKeyMaps = new HashMap<>();
 
-   private Set<String> preloadedKeys;
+   private Set<String> preloadedKeys = new HashSet<>();
 
-   private Set<Pair<String, String>> disallowedOneOffLookups;
-   private boolean                   useSynchronizedCollections;
+   private Set<Pair<String, String>> disallowedOneOffLookups = new HashSet<>();
 
 
 
@@ -69,33 +67,6 @@ public class RecordLookupHelper
     *******************************************************************************/
    public RecordLookupHelper()
    {
-      this(false);
-   }
-
-
-
-   /*******************************************************************************
-    ** Constructor
-    **
-    *******************************************************************************/
-   public RecordLookupHelper(boolean useSynchronizedCollections)
-   {
-      this.useSynchronizedCollections = useSynchronizedCollections;
-
-      if(useSynchronizedCollections)
-      {
-         recordMaps = Collections.synchronizedMap(new HashMap<>());
-         uniqueKeyMaps = Collections.synchronizedMap(new HashMap<>());
-         preloadedKeys = Collections.synchronizedSet(new HashSet<>());
-         disallowedOneOffLookups = Collections.synchronizedSet(new HashSet<>());
-      }
-      else
-      {
-         recordMaps = new HashMap<>();
-         uniqueKeyMaps = new HashMap<>();
-         preloadedKeys = new HashSet<>();
-         disallowedOneOffLookups = new HashSet<>();
-      }
    }
 
 
@@ -106,7 +77,7 @@ public class RecordLookupHelper
    public QRecord getRecordByUniqueKey(String tableName, Map<String, Serializable> uniqueKey) throws QException
    {
       String                                  mapKey    = tableName + "." + uniqueKey.keySet().stream().sorted().collect(Collectors.joining(","));
-      Map<Map<String, Serializable>, QRecord> recordMap = uniqueKeyMaps.computeIfAbsent(mapKey, (k) -> useSynchronizedCollections ? Collections.synchronizedMap(new HashMap<>()) : new HashMap<>());
+      Map<Map<String, Serializable>, QRecord> recordMap = uniqueKeyMaps.computeIfAbsent(mapKey, (k) -> new HashMap<>());
 
       if(!recordMap.containsKey(uniqueKey))
       {
@@ -125,7 +96,7 @@ public class RecordLookupHelper
    public QRecord getRecordByKey(String tableName, String keyFieldName, Serializable key) throws QException
    {
       String                     mapKey    = tableName + "." + keyFieldName;
-      Map<Serializable, QRecord> recordMap = recordMaps.computeIfAbsent(mapKey, (k) -> useSynchronizedCollections ? Collections.synchronizedMap(new HashMap<>()) : new HashMap<>());
+      Map<Serializable, QRecord> recordMap = recordMaps.computeIfAbsent(mapKey, (k) -> new HashMap<>());
 
       ////////////////////////////////////////////////////////////
       // make sure we have they key object in the expected type //
@@ -179,7 +150,7 @@ public class RecordLookupHelper
    public void preloadRecords(String tableName, String keyFieldName, QQueryFilter filter) throws QException
    {
       String                     mapKey   = tableName + "." + keyFieldName;
-      Map<Serializable, QRecord> tableMap = recordMaps.computeIfAbsent(mapKey, s -> useSynchronizedCollections ? Collections.synchronizedMap(new HashMap<>()) : new HashMap<>());
+      Map<Serializable, QRecord> tableMap = recordMaps.computeIfAbsent(mapKey, s -> new HashMap<>());
       tableMap.putAll(GeneralProcessUtils.loadTableToMap(tableName, keyFieldName, filter));
    }
 
@@ -199,7 +170,7 @@ public class RecordLookupHelper
       }
 
       String                     mapKey   = tableName + "." + keyFieldName;
-      Map<Serializable, QRecord> tableMap = recordMaps.computeIfAbsent(mapKey, s -> useSynchronizedCollections ? Collections.synchronizedMap(new HashMap<>()) : new HashMap<>());
+      Map<Serializable, QRecord> tableMap = recordMaps.computeIfAbsent(mapKey, s -> new HashMap<>());
 
       QQueryFilter filter = new QQueryFilter(new QFilterCriteria(keyFieldName, QCriteriaOperator.IN, inList));
       tableMap.putAll(GeneralProcessUtils.loadTableToMap(tableName, keyFieldName, filter));

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/state/InMemoryStateProvider.java

@@ -25,7 +25,6 @@ package com.kingsrook.qqq.backend.core.state;
 import java.io.Serializable;
 import java.time.Instant;
 import java.time.temporal.ChronoUnit;
-import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Optional;
@@ -59,7 +58,7 @@ public class InMemoryStateProvider implements StateProviderInterface
     *******************************************************************************/
    private InMemoryStateProvider()
    {
-      this.map = Collections.synchronizedMap(new HashMap<>());
+      this.map = new HashMap<>();
 
       ///////////////////////////////////////////////////////////
       // Start a single thread executor to handle the cleaning //

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/utils/StringUtils.java

@@ -489,24 +489,6 @@ public class StringUtils
 
 
 
-   /***************************************************************************
-    **
-    ***************************************************************************/
-   public static boolean safeEqualsIgnoreCase(String a, String b)
-   {
-      if(a == null && b == null)
-      {
-         return true;
-      }
-      if(a == null || b == null)
-      {
-         return false;
-      }
-      return (a.equalsIgnoreCase(b));
-   }
-
-
-
    /***************************************************************************
     **
     ***************************************************************************/

qqq-backend-core/src/test/java/com/kingsrook/qqq/backend/core/actions/templates/ConvertHtmlToPdfActionTest.java

@@ -79,7 +79,6 @@ class ConvertHtmlToPdfActionTest extends BaseTest
                      </h1>
                      <div class="myclass">
                          <p>This is a test of converting HTML to PDF!!</p>
-                         <p>This is &nbsp; a line with &bull; some entities &lt;</p>
                          <p style="font-family: SF-Pro; font-size: 24px;">(btw, is this in SF-Pro???)</p>
                      </div>
                  </div>

qqq-backend-core/src/test/java/com/kingsrook/qqq/backend/core/model/actions/processes/ProcessSummaryLineInterfaceAssert.java

@@ -185,13 +185,4 @@ public class ProcessSummaryLineInterfaceAssert extends AbstractAssert<ProcessSum
       return (this);
    }
 
-
-   /***************************************************************************
-    **
-    ***************************************************************************/
-   public ProcessSummaryLineInterface getLine()
-   {
-      return actual;
-   }
-
 }

qqq-backend-core/src/test/java/com/kingsrook/qqq/backend/core/processes/implementations/bulk/insert/BulkInsertFullProcessTest.java

@@ -29,26 +29,15 @@ import java.util.List;
 import java.util.Map;
 import java.util.UUID;
 import com.kingsrook.qqq.backend.core.BaseTest;
-import com.kingsrook.qqq.backend.core.actions.customizers.AbstractPreInsertCustomizer;
-import com.kingsrook.qqq.backend.core.actions.customizers.TableCustomizerInterface;
-import com.kingsrook.qqq.backend.core.actions.customizers.TableCustomizers;
 import com.kingsrook.qqq.backend.core.actions.processes.RunProcessAction;
 import com.kingsrook.qqq.backend.core.actions.tables.StorageAction;
-import com.kingsrook.qqq.backend.core.context.QContext;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
 import com.kingsrook.qqq.backend.core.model.actions.processes.ProcessSummaryAssert;
-import com.kingsrook.qqq.backend.core.model.actions.processes.ProcessSummaryLine;
-import com.kingsrook.qqq.backend.core.model.actions.processes.ProcessSummaryLineInterface;
 import com.kingsrook.qqq.backend.core.model.actions.processes.RunProcessInput;
 import com.kingsrook.qqq.backend.core.model.actions.processes.RunProcessOutput;
-import com.kingsrook.qqq.backend.core.model.actions.processes.Status;
-import com.kingsrook.qqq.backend.core.model.actions.tables.insert.InsertInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.storage.StorageInput;
 import com.kingsrook.qqq.backend.core.model.data.QRecord;
-import com.kingsrook.qqq.backend.core.model.metadata.code.QCodeReference;
 import com.kingsrook.qqq.backend.core.model.metadata.frontend.QFrontendFieldMetaData;
-import com.kingsrook.qqq.backend.core.model.statusmessages.BadInputStatusMessage;
-import com.kingsrook.qqq.backend.core.model.statusmessages.QWarningMessage;
 import com.kingsrook.qqq.backend.core.modules.backend.implementations.memory.MemoryRecordStore;
 import com.kingsrook.qqq.backend.core.processes.implementations.bulk.insert.model.BulkLoadProfile;
 import com.kingsrook.qqq.backend.core.processes.implementations.bulk.insert.model.BulkLoadProfileField;
@@ -187,15 +176,7 @@ class BulkInsertFullProcessTest extends BaseTest
       assertThat(runProcessOutput.getValues().get(StreamedETLWithFrontendProcess.FIELD_PROCESS_SUMMARY)).isNotNull().isInstanceOf(List.class);
       assertThat(runProcessOutput.getException()).isEmpty();
 
-      ProcessSummaryLineInterface okLine = ProcessSummaryAssert.assertThat(runProcessOutput)
-         .hasLineWithMessageContaining("Person Memory records were inserted")
-         .hasStatus(Status.OK)
-         .hasCount(2)
-         .getLine();
-      assertEquals(List.of(1, 2), ((ProcessSummaryLine) okLine).getPrimaryKeys());
-
-      ProcessSummaryAssert.assertThat(runProcessOutput).hasLineWithMessageContaining("records were processed from the file").hasStatus(Status.INFO);
-      ProcessSummaryAssert.assertThat(runProcessOutput).hasLineWithMessageContaining("Inserted Id values between 1 and 2").hasStatus(Status.INFO);
+      ProcessSummaryAssert.assertThat(runProcessOutput).hasLineWithMessageContaining("Inserted Id values between 1 and 2");
 
       ////////////////////////////////////
       // query for the inserted records //
@@ -220,86 +201,6 @@ class BulkInsertFullProcessTest extends BaseTest
 
 
 
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   @Test
-   void testSummaryLinePrimaryKeys() throws Exception
-   {
-      assertThat(TestUtils.queryTable(TestUtils.TABLE_NAME_PERSON_MEMORY)).isEmpty();
-      QContext.getQInstance().getTable(TestUtils.TABLE_NAME_PERSON_MEMORY)
-         .withCustomizer(TableCustomizers.PRE_INSERT_RECORD, new QCodeReference(PersonWarnOrErrorCustomizer.class));
-
-      /////////////////////////////////////////////////////////
-      // start the process - expect to go to the upload step //
-      /////////////////////////////////////////////////////////
-      RunProcessInput  runProcessInput  = new RunProcessInput();
-      RunProcessOutput runProcessOutput = startProcess(runProcessInput);
-      String           processUUID      = runProcessOutput.getProcessUUID();
-
-      continueProcessPostUpload(runProcessInput, processUUID, simulateFileUploadForWarningCase());
-      continueProcessPostFileMapping(runProcessInput);
-      continueProcessPostValueMapping(runProcessInput);
-      runProcessOutput = continueProcessPostReviewScreen(runProcessInput);
-
-      ProcessSummaryLineInterface okLine = ProcessSummaryAssert.assertThat(runProcessOutput)
-         .hasLineWithMessageContaining("Person Memory record was inserted")
-         .hasStatus(Status.OK)
-         .hasCount(1)
-         .getLine();
-      assertEquals(List.of(1), ((ProcessSummaryLine) okLine).getPrimaryKeys());
-
-      ProcessSummaryLineInterface warnTornadoLine = ProcessSummaryAssert.assertThat(runProcessOutput)
-         .hasLineWithMessageContaining("records were inserted, but had a warning: Tornado warning")
-         .hasStatus(Status.WARNING)
-         .hasCount(2)
-         .getLine();
-      assertEquals(List.of(2, 3), ((ProcessSummaryLine) warnTornadoLine).getPrimaryKeys());
-
-      ProcessSummaryAssert.assertThat(runProcessOutput).hasLineWithMessageContaining("record was inserted, but had a warning: Hurricane warning").hasStatus(Status.WARNING).hasCount(1);
-      ProcessSummaryAssert.assertThat(runProcessOutput).hasLineWithMessageContaining("records were processed from the file").hasStatus(Status.INFO).hasCount(4);
-      ProcessSummaryAssert.assertThat(runProcessOutput).hasLineWithMessageContaining("Inserted Id values between 1 and 4").hasStatus(Status.INFO);
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   @Test
-   void testSummaryLineErrors() throws Exception
-   {
-      assertThat(TestUtils.queryTable(TestUtils.TABLE_NAME_PERSON_MEMORY)).isEmpty();
-      QContext.getQInstance().getTable(TestUtils.TABLE_NAME_PERSON_MEMORY)
-         .withCustomizer(TableCustomizers.PRE_INSERT_RECORD, new QCodeReference(PersonWarnOrErrorCustomizer.class));
-
-      /////////////////////////////////////////////////////////
-      // start the process - expect to go to the upload step //
-      /////////////////////////////////////////////////////////
-      RunProcessInput  runProcessInput  = new RunProcessInput();
-      RunProcessOutput runProcessOutput = startProcess(runProcessInput);
-      String           processUUID      = runProcessOutput.getProcessUUID();
-
-      continueProcessPostUpload(runProcessInput, processUUID, simulateFileUploadForErrorCase());
-      continueProcessPostFileMapping(runProcessInput);
-      continueProcessPostValueMapping(runProcessInput);
-      runProcessOutput = continueProcessPostReviewScreen(runProcessInput);
-
-      ProcessSummaryAssert.assertThat(runProcessOutput).hasLineWithMessageContaining("Person Memory record was inserted.").hasStatus(Status.OK).hasCount(1);
-
-      ProcessSummaryAssert.assertThat(runProcessOutput)
-         .hasLineWithMessageContaining("plane")
-         .hasStatus(Status.ERROR)
-         .hasCount(1);
-
-      ProcessSummaryAssert.assertThat(runProcessOutput)
-         .hasLineWithMessageContaining("purifier")
-         .hasStatus(Status.ERROR)
-         .hasCount(1);
-   }
-
-
-
    /*******************************************************************************
     **
     *******************************************************************************/
@@ -400,47 +301,6 @@ class BulkInsertFullProcessTest extends BaseTest
 
 
 
-   /***************************************************************************
-    **
-    ***************************************************************************/
-   private static StorageInput simulateFileUploadForWarningCase() throws Exception
-   {
-      String       storageReference = UUID.randomUUID() + ".csv";
-      StorageInput storageInput     = new StorageInput(TestUtils.TABLE_NAME_MEMORY_STORAGE).withReference(storageReference);
-      try(OutputStream outputStream = new StorageAction().createOutputStream(storageInput))
-      {
-         outputStream.write((getPersonCsvHeaderUsingLabels() + """
-            "0","2021-10-26 14:39:37","2021-10-26 14:39:37","John","Doe","1980-01-01","john@doe.com","Missouri",42
-            "0","2021-10-26 14:39:37","2021-10-26 14:39:37","Tornado warning","Doe","1980-01-01","john@doe.com","Missouri",42
-            "0","2021-10-26 14:39:37","2021-10-26 14:39:37","Tornado warning","Doey","1980-01-01","john@doe.com","Missouri",42
-            "0","2021-10-26 14:39:37","2021-10-26 14:39:37","Hurricane warning","Doe","1980-01-01","john@doe.com","Missouri",42
-            """).getBytes());
-      }
-      return storageInput;
-   }
-
-
-
-   /***************************************************************************
-    **
-    ***************************************************************************/
-   private static StorageInput simulateFileUploadForErrorCase() throws Exception
-   {
-      String       storageReference = UUID.randomUUID() + ".csv";
-      StorageInput storageInput     = new StorageInput(TestUtils.TABLE_NAME_MEMORY_STORAGE).withReference(storageReference);
-      try(OutputStream outputStream = new StorageAction().createOutputStream(storageInput))
-      {
-         outputStream.write((getPersonCsvHeaderUsingLabels() + """
-            "0","2021-10-26 14:39:37","2021-10-26 14:39:37","John","Doe","1980-01-01","john@doe.com","Missouri",42
-            "0","2021-10-26 14:39:37","2021-10-26 14:39:37","not-pre-Error plane","Doe","1980-01-01","john@doe.com","Missouri",42
-            "0","2021-10-26 14:39:37","2021-10-26 14:39:37","Error purifier","Doe","1980-01-01","john@doe.com","Missouri",42
-            """).getBytes());
-      }
-      return storageInput;
-   }
-
-
-
    /***************************************************************************
     **
     ***************************************************************************/
@@ -471,47 +331,4 @@ class BulkInsertFullProcessTest extends BaseTest
       )));
    }
 
-
-
-   /***************************************************************************
-    **
-    ***************************************************************************/
-   public static class PersonWarnOrErrorCustomizer implements TableCustomizerInterface
-   {
-      /***************************************************************************
-       **
-       ***************************************************************************/
-      @Override
-      public AbstractPreInsertCustomizer.WhenToRun whenToRunPreInsert(InsertInput insertInput, boolean isPreview)
-      {
-         return AbstractPreInsertCustomizer.WhenToRun.BEFORE_ALL_VALIDATIONS;
-      }
-
-
-
-      /***************************************************************************
-       **
-       ***************************************************************************/
-      @Override
-      public List<QRecord> preInsert(InsertInput insertInput, List<QRecord> records, boolean isPreview) throws QException
-      {
-         for(QRecord record : records)
-         {
-            if(record.getValueString("firstName").toLowerCase().contains("warn"))
-            {
-               record.addWarning(new QWarningMessage(record.getValueString("firstName")));
-            }
-            else if(record.getValueString("firstName").toLowerCase().contains("error"))
-            {
-               if(isPreview && record.getValueString("firstName").toLowerCase().contains("not-pre-error"))
-               {
-                  continue;
-               }
-
-               record.addError(new BadInputStatusMessage(record.getValueString("firstName")));
-            }
-         }
-         return records;
-      }
-   }
 }

qqq-backend-core/src/test/java/com/kingsrook/qqq/backend/core/processes/utils/RecordLookupHelperTest.java

@@ -22,15 +22,8 @@
 package com.kingsrook.qqq.backend.core.processes.utils;
 
 
-import java.util.ArrayList;
-import java.util.ConcurrentModificationException;
 import java.util.List;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.Future;
 import com.kingsrook.qqq.backend.core.BaseTest;
-import com.kingsrook.qqq.backend.core.context.CapturedContext;
 import com.kingsrook.qqq.backend.core.context.QContext;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
 import com.kingsrook.qqq.backend.core.model.metadata.QInstance;
@@ -39,7 +32,6 @@ import com.kingsrook.qqq.backend.core.utils.TestUtils;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import static org.assertj.core.api.Fail.fail;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertNull;
@@ -203,54 +195,4 @@ class RecordLookupHelperTest extends BaseTest
       assertEquals(1, MemoryRecordStore.getStatistics().get(MemoryRecordStore.STAT_QUERIES_RAN));
    }
 
-
-
-   /*******************************************************************************
-    ** run a lot of threads (eg, 100), each trying to do lots of work in a
-    ** shared recordLookupHelper.  w/o the flag to use sync'ed collections, this
-    ** (usually?) fails with a ConcurrentModificationException - but with the sync'ed
-    ** collections, is safe.
-    *******************************************************************************/
-   @Test
-   void testConcurrentModification() throws InterruptedException, ExecutionException
-   {
-      ExecutorService    executorService    = Executors.newFixedThreadPool(100);
-      RecordLookupHelper recordLookupHelper = new RecordLookupHelper(true);
-
-      CapturedContext capture = QContext.capture();
-
-      List<Future<?>> futures = new ArrayList<>();
-      for(int i = 0; i < 100; i++)
-      {
-         int finalI = i;
-         Future<?> future = executorService.submit(() ->
-         {
-            QContext.init(capture);
-            for(int j = 0; j < 25000; j++)
-            {
-               try
-               {
-                  recordLookupHelper.getRecordByKey(String.valueOf(j), "id", j);
-               }
-               catch(ConcurrentModificationException cme)
-               {
-                  fail("CME!", cme);
-               }
-               catch(Exception e)
-               {
-                  //////////////
-                  // expected //
-                  //////////////
-               }
-            }
-         });
-         futures.add(future);
-      }
-
-      for(Future<?> future : futures)
-      {
-         future.get();
-      }
-   }
-
 }

qqq-backend-core/src/test/java/com/kingsrook/qqq/backend/core/state/InMemoryStateProviderTest.java

@@ -25,8 +25,6 @@ package com.kingsrook.qqq.backend.core.state;
 import java.time.Instant;
 import java.time.temporal.ChronoUnit;
 import java.util.UUID;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
 import com.kingsrook.qqq.backend.core.BaseTest;
 import com.kingsrook.qqq.backend.core.model.data.QRecord;
 import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
@@ -105,17 +103,17 @@ public class InMemoryStateProviderTest extends BaseTest
       /////////////////////////////////////////////////////////////
       // Add an entry that is 3 hours old, should not be cleaned //
       /////////////////////////////////////////////////////////////
-      UUIDAndTypeStateKey newKey     = new UUIDAndTypeStateKey(UUID.randomUUID(), StateType.PROCESS_STATUS, Instant.now().minus(3, ChronoUnit.HOURS));
-      String              newUUID    = UUID.randomUUID().toString();
-      QRecord             newQRecord = new QRecord().withValue("uuid", newUUID);
+      UUIDAndTypeStateKey   newKey           = new UUIDAndTypeStateKey(UUID.randomUUID(), StateType.PROCESS_STATUS, Instant.now().minus(3, ChronoUnit.HOURS));
+      String  newUUID    = UUID.randomUUID().toString();
+      QRecord newQRecord = new QRecord().withValue("uuid", newUUID);
       stateProvider.put(newKey, newQRecord);
 
       ////////////////////////////////////////////////////////////
       // Add an entry that is 5 hours old, it should be cleaned //
       ////////////////////////////////////////////////////////////
-      UUIDAndTypeStateKey oldKey     = new UUIDAndTypeStateKey(UUID.randomUUID(), StateType.PROCESS_STATUS, Instant.now().minus(5, ChronoUnit.HOURS));
-      String              oldUUID    = UUID.randomUUID().toString();
-      QRecord             oldQRecord = new QRecord().withValue("uuid", oldUUID);
+      UUIDAndTypeStateKey   oldKey           = new UUIDAndTypeStateKey(UUID.randomUUID(), StateType.PROCESS_STATUS, Instant.now().minus(5, ChronoUnit.HOURS));
+      String  oldUUID    = UUID.randomUUID().toString();
+      QRecord oldQRecord = new QRecord().withValue("uuid", oldUUID);
       stateProvider.put(oldKey, oldQRecord);
 
       ///////////////////
@@ -127,33 +125,7 @@ public class InMemoryStateProviderTest extends BaseTest
       Assertions.assertEquals(newUUID, qRecordFromState.getValueString("uuid"), "Should read value from state persistence");
 
       Assertions.assertTrue(stateProvider.get(QRecord.class, oldKey).isEmpty(), "Key not found in state should return empty");
-   }
 
-
-
-   /*******************************************************************************
-    ** originally written with N=100000, but showed the error as small as 1000.
-    *******************************************************************************/
-   @Test
-   void testDemonstrateConcurrentModificationIfNonSynchronizedMap()
-   {
-      int N = 1000;
-      InMemoryStateProvider stateProvider = InMemoryStateProvider.getInstance();
-
-      ExecutorService executorService = Executors.newFixedThreadPool(10);
-      executorService.submit(() ->
-      {
-         for(int i = 0; i < N; i++)
-         {
-            UUIDAndTypeStateKey oldKey = new UUIDAndTypeStateKey(UUID.randomUUID(), StateType.PROCESS_STATUS, Instant.now().minus(5, ChronoUnit.HOURS));
-            stateProvider.put(oldKey, UUID.randomUUID());
-         }
-      });
-
-      for(int i = 0; i < N; i++)
-      {
-         stateProvider.clean(Instant.now().minus(4, ChronoUnit.HOURS));
-      }
    }
 
 }

qqq-backend-core/src/test/java/com/kingsrook/qqq/backend/core/utils/StringUtilsTest.java

@@ -350,22 +350,4 @@ class StringUtilsTest extends BaseTest
       assertEquals("test ((2)) (101)", StringUtils.appendIncrementingSuffix("test ((2)) (100)"));
    }
 
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   @Test
-   void testSafeEqualsIgnoreCase()
-   {
-      assertTrue(StringUtils.safeEqualsIgnoreCase(null, null));
-      assertFalse(StringUtils.safeEqualsIgnoreCase("a", null));
-      assertFalse(StringUtils.safeEqualsIgnoreCase(null, "a"));
-      assertTrue(StringUtils.safeEqualsIgnoreCase("a", "a"));
-      assertTrue(StringUtils.safeEqualsIgnoreCase("A", "a"));
-      assertFalse(StringUtils.safeEqualsIgnoreCase("a", "b"));
-      assertTrue(StringUtils.safeEqualsIgnoreCase("timothy d. chamberlain", "TIMOThy d. chaMberlain"));
-      assertTrue(StringUtils.safeEqualsIgnoreCase("timothy d. chamberlain", "timothy d. chamberlain"));
-   }
-
 }

qqq-language-support-javascript/pom.xml

@@ -47,14 +47,9 @@
 
       <!-- 3rd party deps specifically for this module -->
       <dependency>
-         <groupId>org.graalvm.js</groupId>
-         <artifactId>js</artifactId>
-         <version>22.3.0</version>
-      </dependency>
-      <dependency>
-         <groupId>org.graalvm.js</groupId>
-         <artifactId>js-scriptengine</artifactId>
-         <version>22.3.0</version>
+         <groupId>org.openjdk.nashorn</groupId>
+         <artifactId>nashorn-core</artifactId>
+         <version>15.4</version>
       </dependency>
 
       <!-- Common deps for all qqq modules -->

qqq-language-support-javascript/src/main/java/com/kingsrook/qqq/languages/javascript/QJavaScriptExecutor.java

@@ -21,9 +21,11 @@
 
 package com.kingsrook.qqq.languages.javascript;
 
-// Javax imports removed for GraalVM migration
-
 
+import javax.script.Bindings;
+import javax.script.ScriptEngine;
+import javax.script.ScriptEngineManager;
+import javax.script.ScriptException;
 import java.io.Serializable;
 import java.math.BigDecimal;
 import java.time.Instant;
@@ -37,11 +39,14 @@ import com.kingsrook.qqq.backend.core.actions.scripts.logging.QCodeExecutionLogg
 import com.kingsrook.qqq.backend.core.exceptions.QCodeException;
 import com.kingsrook.qqq.backend.core.logging.QLogger;
 import com.kingsrook.qqq.backend.core.model.metadata.code.QCodeReference;
+import com.kingsrook.qqq.backend.core.utils.ExceptionUtils;
 import com.kingsrook.qqq.backend.core.utils.StringUtils;
 import org.apache.commons.lang.NotImplementedException;
-import org.graalvm.polyglot.Context;
-import org.graalvm.polyglot.Source;
-import org.graalvm.polyglot.Value;
+import org.openjdk.nashorn.api.scripting.NashornScriptEngineFactory;
+import org.openjdk.nashorn.api.scripting.ScriptObjectMirror;
+import org.openjdk.nashorn.internal.runtime.ECMAException;
+import org.openjdk.nashorn.internal.runtime.ParserException;
+import org.openjdk.nashorn.internal.runtime.Undefined;
 
 
 /*******************************************************************************
@@ -86,85 +91,57 @@ public class QJavaScriptExecutor implements QCodeExecutor
          {
             return (new BigDecimal(d));
          }
-         else if(object instanceof Value val)
+         else if(object instanceof Undefined)
+         {
+            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
+            // well, we always said we wanted javascript to treat null & undefined the same way...  here's our chance //
+            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
+            return (null);
+         }
+
+         if(object instanceof ScriptObjectMirror scriptObjectMirror)
          {
             try
             {
-               //////////////////////////////////////////////////
-               // treat JavaScript null/undefined as Java null //
-               //////////////////////////////////////////////////
-               if(val.isNull() || val.isHostObject() && val.asHostObject() == null)
+               if("Date".equals(scriptObjectMirror.getClassName()))
                {
-                  return null;
-               }
-               ////////////////
-               // primitives //
-               ////////////////
-               if(val.isString())
-               {
-                  return val.asString();
-               }
-               if(val.isBoolean())
-               {
-                  return val.asBoolean();
-               }
-               if(val.isNumber())
-               {
-                  //////////////////////////////////////////
-                  // preserve integer types when possible //
-                  //////////////////////////////////////////
-                  if(val.fitsInInt())
-                  {
-                     return val.asInt();
-                  }
-                  else if(val.fitsInLong())
-                  {
-                     return val.asLong();
-                  }
-                  else
-                  {
-                     return new BigDecimal(val.asDouble());
-                  }
-               }
-               //////////////////////////////////////////////
-               // detect JS Date by existence of getTime() //
-               //////////////////////////////////////////////
-               if(val.hasMember("getTime") && val.canInvokeMember("getTime"))
-               {
-                  double millis = val.invokeMember("getTime").asDouble();
-                  return Instant.ofEpochMilli((long) millis);
-               }
-               ////////////
-               // arrays //
-               ////////////
-               if(val.hasArrayElements())
-               {
-                  List<Object> result = new ArrayList<>();
-                  long         size   = val.getArraySize();
-                  for(long i = 0; i < size; i++)
-                  {
-                     result.add(convertObjectToJava(val.getArrayElement(i)));
-                  }
-                  return result;
-               }
-               /////////////
-               // objects //
-               /////////////
-               if(val.hasMembers())
-               {
-                  Map<String, Object> result = new HashMap<>();
-                  for(String key : val.getMemberKeys())
-                  {
-                     result.put(key, convertObjectToJava(val.getMember(key)));
-                  }
-                  return result;
+                  ////////////////////////////////////////////////////////////////////
+                  // looks like the js Date is in UTC (is that because our JVM is?) //
+                  // so the instant being in UTC matches                            //
+                  ////////////////////////////////////////////////////////////////////
+                  Double  millis  = (Double) scriptObjectMirror.callMember("getTime");
+                  Instant instant = Instant.ofEpochMilli(millis.longValue());
+                  return (instant);
                }
             }
             catch(Exception e)
             {
-               LOG.debug("Error converting GraalVM value", e);
+               LOG.debug("Error unwrapping javascript date", e);
+            }
+
+            if(scriptObjectMirror.isArray())
+            {
+               List<Object> result = new ArrayList<>();
+               for(String key : scriptObjectMirror.keySet())
+               {
+                  result.add(Integer.parseInt(key), convertObjectToJava(scriptObjectMirror.get(key)));
+               }
+               return (result);
+            }
+            else
+            {
+               ///////////////////////////////////////////////////////////////////////////////////////////////////////
+               // last thing we know to try (though really, there's probably some check we should have around this) //
+               ///////////////////////////////////////////////////////////////////////////////////////////////////////
+               Map<String, Object> result = new HashMap<>();
+               for(String key : scriptObjectMirror.keySet())
+               {
+                  result.put(key, convertObjectToJava(scriptObjectMirror.get(key)));
+               }
+               return (result);
             }
          }
+
          return QCodeExecutor.super.convertObjectToJava(object);
       }
       catch(Exception e)
@@ -188,14 +165,9 @@ public class QJavaScriptExecutor implements QCodeExecutor
          {
             if(object instanceof Instant i)
             {
-               long millis = (i.getEpochSecond() * 1000 + i.getLong(ChronoField.MILLI_OF_SECOND));
-               Context context = Context.newBuilder("js")
-                  .allowAllAccess(true)
-                  .allowExperimentalOptions(true)
-                  .option("js.ecmascript-version", "2022")
-                  .build();
-               Value jsDate = context.eval("js", "new Date(" + millis + ")");
-               return jsDate.asHostObject();
+               long         millis = (i.getEpochSecond() * 1000 + i.getLong(ChronoField.MILLI_OF_SECOND));
+               ScriptEngine engine = new ScriptEngineManager().getEngineByName("nashorn");
+               return engine.eval("new Date(" + millis + ")");
             }
          }
 
@@ -214,29 +186,32 @@ public class QJavaScriptExecutor implements QCodeExecutor
     *******************************************************************************/
    private Serializable runInline(String code, Map<String, Serializable> inputContext, QCodeExecutionLoggerInterface executionLogger) throws QCodeException
    {
-      Context context = Context.newBuilder("js")
-         .allowAllAccess(true)
-         .allowExperimentalOptions(true)
-         .option("js.ecmascript-version", "2022")
-         .build();
-      // Populate GraalJS bindings from the inputContext
-      Value bindingsScope = context.getBindings("js");
-      for(Map.Entry<String, Serializable> entry : inputContext.entrySet())
+      new NashornScriptEngineFactory();
+      ScriptEngine engine = new ScriptEngineManager().getEngineByName("nashorn");
+
+      //////////////////////////////////////////////
+      // setup the javascript environment/context //
+      //////////////////////////////////////////////
+      Bindings bindings = engine.createBindings();
+      bindings.putAll(inputContext);
+
+      if(!bindings.containsKey("logger"))
       {
-         bindingsScope.putMember(entry.getKey(), entry.getValue());
+         bindings.put("logger", executionLogger);
       }
-      // Ensure logger is available
-      if(!bindingsScope.hasMember("logger"))
-      {
-         bindingsScope.putMember("logger", executionLogger);
-      }
-      // wrap the user's code in an immediately-invoked function expression
+
+      ////////////////////////////////////////////////////////////////////////
+      // wrap the user's code in an immediately-invoked function expression //
+      // if the user's code (%s below) returns - then our IIFE is done.     //
+      // if the user's code doesn't return, but instead created a 'script'  //
+      // variable, with a 'main' function on it (e.g., from a compiled      //
+      // type script file), then call main function and return its result.  //
+      ////////////////////////////////////////////////////////////////////////
       String codeToRun = """
          (function userDefinedFunction()
          {
-            'use strict';
             %s
-         
+
             var mainFunction = null;
             try
             {
@@ -246,7 +221,7 @@ public class QJavaScriptExecutor implements QCodeExecutor
                }
             }
             catch(e) { }
-         
+
             if(mainFunction != null)
             {
                return (mainFunction());
@@ -257,25 +232,66 @@ public class QJavaScriptExecutor implements QCodeExecutor
       Serializable output;
       try
       {
-         Source source = Source.newBuilder("js", codeToRun, "batchName.js")
-            .mimeType("application/javascript+module")
-            .build();
-         Value result = context.eval(source);
-         output = (Serializable) result.asHostObject();
+         output = (Serializable) engine.eval(codeToRun, bindings);
       }
-      catch(Exception se)
+      catch(ScriptException se)
       {
-         // We no longer have ScriptException, so wrap as QCodeException
-         throw new QCodeException("Error during JavaScript execution: " + se.getMessage(), se);
+         QCodeException qCodeException = getQCodeExceptionFromScriptException(se);
+         throw (qCodeException);
       }
 
       return (output);
    }
 
+
+
    /*******************************************************************************
     **
     *******************************************************************************/
-   // getQCodeExceptionFromScriptException is now unused (ScriptException/Nashorn removed)
+   private QCodeException getQCodeExceptionFromScriptException(ScriptException se)
+   {
+      boolean isParserException     = ExceptionUtils.findClassInRootChain(se, ParserException.class) != null;
+      boolean isUserThrownException = ExceptionUtils.findClassInRootChain(se, ECMAException.class) != null;
+
+      String message      = se.getMessage();
+      String errorContext = null;
+      if(message != null)
+      {
+         message = message.replaceFirst(" in <eval>.*", "");
+         message = message.replaceFirst("<eval>:\\d+:\\d+", "");
+
+         if(message.contains("\n"))
+         {
+            String[] parts = message.split("\n", 2);
+            message = parts[0];
+            errorContext = parts[1];
+         }
+      }
+
+      int actualScriptLineNumber = se.getLineNumber() - 2;
+
+      String  prefix         = "Script Exception";
+      boolean includeColumn  = true;
+      boolean includeContext = false;
+      if(isParserException)
+      {
+         prefix = "Script parser exception";
+         includeContext = true;
+      }
+      else if(isUserThrownException)
+      {
+         prefix = "Script threw an exception";
+         includeColumn = false;
+      }
+
+      QCodeException qCodeException = new QCodeException(prefix + " at line " + actualScriptLineNumber + (includeColumn ? (" column " + se.getColumnNumber()) : "") + ": " + message);
+      if(includeContext)
+      {
+         qCodeException.setContext(errorContext);
+      }
+
+      return (qCodeException);
+   }
 
 
 

qqq-middleware-javalin/src/main/java/com/kingsrook/qqq/middleware/javalin/specs/v1/utils/ProcessSpecUtilsV1.java

@@ -163,6 +163,7 @@ public class ProcessSpecUtilsV1
       JSONObject outputJsonObject = convertResponseToJSONObject(response);
 
       String json = outputJsonObject.toString(3);
+      System.out.println(json);
       context.result(json);
    }
 
@@ -307,8 +308,8 @@ public class ProcessSpecUtilsV1
    private static void archiveUploadedFile(String processName, QUploadedFile qUploadedFile)
    {
       String fileName = QValueFormatter.formatDate(LocalDate.now())
-         + File.separator + processName
-         + File.separator + qUploadedFile.getFilename();
+                        + File.separator + processName
+                        + File.separator + qUploadedFile.getFilename();
 
       InsertInput insertInput = new InsertInput();
       insertInput.setTableName(QJavalinImplementation.getJavalinMetaData().getUploadedFileArchiveTableName());