i guess methods starting with underscores are not allowed

Feature/ce 609 infrastructure remove permissions from header

.circleci/adjust-pom-version.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+
+if [ -z "$CIRCLE_BRANCH" ] && [ -z "$CIRCLE_TAG" ]; then
+   echo "Error:  env vars CIRCLE_BRANCH and CIRCLE_TAG were not set."
+   exit 1;
+fi
+
+if [ "$CIRCLE_BRANCH" == "dev" ] || [ "$CIRCLE_BRANCH" == "staging" ] || [ "$CIRCLE_BRANCH" == "main" ] || [ \! -z $(echo "$CIRCLE_TAG" | grep "^version-") ]; then
+   echo "On a primary branch or tag [${CIRCLE_BRANCH}${CIRCLE_TAG}] - will not edit the pom version.";
+   exit 0;
+fi
+
+if [ -n "$CIRCLE_BRANCH" ]; then
+   SLUG=$(echo $CIRCLE_BRANCH | sed 's/[^a-zA-Z0-9]/-/g')
+else
+   SLUG=$(echo $CIRCLE_TAG | sed 's/^snapshot-//g')
+fi
+
+POM=$(dirname $0)/../pom.xml
+
+echo "Updating $POM <revision> to: $SLUG-SNAPSHOT"
+sed -i "s/<revision>.*/<revision>$SLUG-SNAPSHOT<\/revision>/" $POM
+git diff $POM

.circleci/config.yml

@@ -1,7 +1,6 @@
 version: 2.1
 
 orbs:
-  slack: circleci/slack@4.10.1
   localstack: localstack/platform@1.0
 
 commands:
@@ -12,8 +11,10 @@ commands:
     steps:
       - store_artifacts:
           path: << parameters.module >>/target/site/jacoco/index.html
+          when: always
       - store_artifacts:
           path: << parameters.module >>/target/site/jacoco/jacoco-resources
+          when: always
 
   install_java17:
     steps:
@@ -24,6 +25,12 @@ commands:
             sudo apt install -y openjdk-17-jdk
             sudo rm /etc/alternatives/java
             sudo ln -s /usr/lib/jvm/java-17-openjdk-amd64/bin/java /etc/alternatives/java
+      - run:
+          ## used by jacoco uncovered class reporting in pom.xml
+          name: Install html2text
+          command: |
+            sudo apt-get update
+            sudo apt-get install -y html2text
 
   mvn_verify:
     steps:
@@ -45,10 +52,18 @@ commands:
           module: qqq-backend-module-filesystem
       - store_jacoco_site:
           module: qqq-backend-module-rdbms
+      - store_jacoco_site:
+          module: qqq-backend-module-api
+      - store_jacoco_site:
+          module: qqq-middleware-api
       - store_jacoco_site:
           module: qqq-middleware-javalin
       - store_jacoco_site:
           module: qqq-middleware-picocli
+      - store_jacoco_site:
+          module: qqq-middleware-slack
+      - store_jacoco_site:
+          module: qqq-language-support-javascript
       - store_jacoco_site:
           module: qqq-sample-project
       - run:
@@ -67,6 +82,10 @@ commands:
   mvn_jar_deploy:
     steps:
       - checkout
+      - run:
+          name: Adjust pom version
+          command: |
+            .circleci/adjust-pom-version.sh
       - restore_cache:
           keys:
             - v1-dependencies-{{ checksum "pom.xml" }}
@@ -86,8 +105,6 @@ jobs:
       - localstack/startup
       - install_java17
       - mvn_verify
-      - slack/notify:
-          event: fail
 
   mvn_deploy:
     executor: localstack/default
@@ -96,14 +113,12 @@ jobs:
       - install_java17
       - mvn_verify
       - mvn_jar_deploy
-      - slack/notify:
-          event: always
 
 workflows:
   test_only:
     jobs:
       - mvn_test:
-          context: [ qqq-maven-registry-credentials, kingsrook-slack, build-qqq-sample-app ]
+          context: [ qqq-maven-registry-credentials, build-qqq-sample-app ]
           filters:
             branches:
               ignore: /dev/
@@ -113,7 +128,7 @@ workflows:
   deploy:
     jobs:
       - mvn_deploy:
-          context: [ qqq-maven-registry-credentials, kingsrook-slack, build-qqq-sample-app ]
+          context: [ qqq-maven-registry-credentials, build-qqq-sample-app ]
           filters:
             branches:
               only: /dev/

README.md

@@ -10,7 +10,7 @@ The bundle contains all of the sub-jars.  It is named:
 
 ```qqq-${version}.jar```
 
-You can also use fine grained jars:
+You can also use fine-grained jars:
 - `qqq-backend-core`: The core module.  Useful if you're developing other modules.
 - `qqq-backend-module-rdbms`: Backend module for working with Relational Databases.
 - `qqq-backend-module-filesystem`: Backend module for working with Filesystems (including AWS S3).

pom.xml

@@ -37,13 +37,14 @@
       <module>qqq-middleware-picocli</module>
       <module>qqq-middleware-javalin</module>
       <module>qqq-middleware-lambda</module>
+      <module>qqq-middleware-slack</module>
+      <module>qqq-middleware-api</module>
       <module>qqq-utility-lambdas</module>
       <module>qqq-sample-project</module>
-      <module>qqq-middleware-slack</module>
    </modules>
 
    <properties>
-      <revision>0.10.0</revision>
+      <revision>0.19.0-SNAPSHOT</revision>
 
       <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
       <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
@@ -205,6 +206,63 @@
                <skipUpdateVersion>true</skipUpdateVersion>
             </configuration>
          </plugin>
+         <plugin>
+            <artifactId>exec-maven-plugin</artifactId>
+            <groupId>org.codehaus.mojo</groupId>
+            <version>3.0.0</version>
+            <executions>
+               <execution>
+                  <id>test-coverage-summary</id>
+                  <phase>verify</phase>
+                  <goals>
+                     <goal>exec</goal>
+                  </goals>
+                  <configuration>
+                     <executable>sh</executable>
+                     <arguments>
+                        <argument>-c</argument>
+                        <argument>
+                           <![CDATA[
+if [ ! -e target/site/jacoco/index.html ]; then
+   echo "No jacoco coverage report here.";
+   exit;
+fi
+
+echo
+echo "Jacoco coverage summary report:"
+echo "   See also target/site/jacoco/index.html"
+echo "   and https://www.jacoco.org/jacoco/trunk/doc/counters.html"
+echo "------------------------------------------------------------"
+
+which xpath > /dev/null 2>&1
+if [ "$?" == "0" ]; then
+   echo "Element\nInstructions Missed\nInstruction Coverage\nBranches Missed\nBranch Coverage\nComplexity Missed\nComplexity Hit\nLines Missed\nLines Hit\nMethods Missed\nMethods Hit\nClasses Missed\nClasses Hit\n" > /tmp/$$.headers
+   xpath -n -q -e '/html/body/table/tfoot/tr[1]/td/text()' target/site/jacoco/index.html > /tmp/$$.values
+   paste /tmp/$$.headers /tmp/$$.values | tail +2 | awk -v FS='\t' '{printf("%-20s %s\n",$1,$2)}'
+   rm /tmp/$$.headers /tmp/$$.values
+else
+   echo "xpath is not installed.  Jacoco coverage summary will not be produced here...";
+fi
+
+which xpath > /dev/null 2>&1
+if [ "$?" == "0" ]; then
+   echo "Untested classes, per Jacoco:"
+   echo "-----------------------------"
+   for i in target/site/jacoco/*/index.html; do
+      html2text -width 500 -nobs $i | sed '1,/^Total/d;' | grep -v Created | sed 's/ \+/ /g' | sed 's/ [[:digit:]]$//' | grep -v 0$ | cut -d' ' -f1;
+   done;
+   echo
+else
+   echo "html2text is not installed.  Untested classes from Jacoco will not be printed here...";
+fi
+
+                           ]]>
+                        </argument>
+                     </arguments>
+                  </configuration>
+               </execution>
+            </executions>
+         </plugin>
          <plugin>
             <groupId>org.jacoco</groupId>
             <artifactId>jacoco-maven-plugin</artifactId>
@@ -248,56 +306,14 @@
                </execution>
                <execution>
                   <id>post-unit-test</id>
-                  <phase>verify</phase>
+                  <!-- <phase>verify</phase> -->
+                  <phase>post-integration-test</phase>
                   <goals>
                      <goal>report</goal>
                   </goals>
                </execution>
             </executions>
          </plugin>
-         <plugin>
-            <artifactId>exec-maven-plugin</artifactId>
-            <groupId>org.codehaus.mojo</groupId>
-            <version>3.0.0</version>
-            <executions>
-               <execution>
-                  <id>test-coverage-summary</id>
-                  <phase>verify</phase>
-                  <goals>
-                     <goal>exec</goal>
-                  </goals>
-                  <configuration>
-                     <executable>sh</executable>
-                     <arguments>
-                        <argument>-c</argument>
-                        <argument>
-                           <![CDATA[
-if [ ! -e target/site/jacoco/index.html ]; then
-   echo "No jacoco coverage report here.";
-   exit;
-fi
-
-echo
-echo "Jacoco coverage summary report:"
-echo "   See also target/site/jacoco/index.html"
-echo "   and https://www.jacoco.org/jacoco/trunk/doc/counters.html"
-echo "------------------------------------------------------------"
-which xpath > /dev/null 2>&1
-if [ "$?" == "0" ]; then
-   echo "Element\nInstructions Missed\nInstruction Coverage\nBranches Missed\nBranch Coverage\nComplexity Missed\nComplexity Hit\nLines Missed\nLines Hit\nMethods Missed\nMethods Hit\nClasses Missed\nClasses Hit\n" > /tmp/$$.headers
-   xpath -n -q -e '/html/body/table/tfoot/tr[1]/td/text()' target/site/jacoco/index.html > /tmp/$$.values
-   paste /tmp/$$.headers /tmp/$$.values | tail +2 | awk -v FS='\t' '{printf("%-20s %s\n",$1,$2)}'
-   rm /tmp/$$.headers /tmp/$$.values
-else
-   echo "xpath is not installed.  Jacoco coverage summary will not be produced here..";
-fi
-                           ]]>
-                        </argument>
-                     </arguments>
-                  </configuration>
-               </execution>
-            </executions>
-         </plugin>
       </plugins>
    </build>
 

qqq-backend-core/pom.xml

@@ -56,20 +56,35 @@
          <groupId>software.amazon.awssdk</groupId>
          <artifactId>quicksight</artifactId>
       </dependency>
+      <dependency>
+         <groupId>software.amazon.awssdk</groupId>
+         <artifactId>apigateway</artifactId>
+      </dependency>
+      <dependency>
+         <groupId>com.amazonaws</groupId>
+         <artifactId>aws-java-sdk-secretsmanager</artifactId>
+         <version>1.12.385</version>
+      </dependency>
+
       <dependency>
          <groupId>com.fasterxml.jackson.core</groupId>
          <artifactId>jackson-databind</artifactId>
-         <version>2.14.0-rc1</version>
+         <version>2.14.0</version>
       </dependency>
       <dependency>
          <groupId>com.fasterxml.jackson.datatype</groupId>
          <artifactId>jackson-datatype-jsr310</artifactId>
-         <version>2.13.0</version>
+         <version>2.14.0</version>
+      </dependency>
+      <dependency>
+         <groupId>com.fasterxml.jackson.dataformat</groupId>
+         <artifactId>jackson-dataformat-yaml</artifactId>
+         <version>2.14.0</version>
       </dependency>
       <dependency>
          <groupId>org.json</groupId>
          <artifactId>json</artifactId>
-         <version>20210307</version>
+         <version>20230227</version>
       </dependency>
       <dependency>
          <groupId>org.apache.commons</groupId>
@@ -89,8 +104,18 @@
       </dependency>
       <dependency>
          <groupId>com.auth0</groupId>
-         <artifactId>mvc-auth-commons</artifactId>
-         <version>1.9.2</version>
+         <artifactId>auth0</artifactId>
+         <version>2.1.0</version>
+      </dependency>
+      <dependency>
+         <groupId>com.auth0</groupId>
+         <artifactId>java-jwt</artifactId>
+         <version>4.4.0</version>
+      </dependency>
+      <dependency>
+         <groupId>com.auth0</groupId>
+         <artifactId>jwks-rsa</artifactId>
+         <version>0.22.0</version>
       </dependency>
       <dependency>
          <groupId>io.github.cdimascio</groupId>

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

@@ -25,6 +25,8 @@ package com.kingsrook.qqq.backend.core.actions;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
+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.actions.AbstractActionInput;
 import com.kingsrook.qqq.backend.core.model.actions.AbstractActionOutput;
@@ -50,11 +52,13 @@ public abstract class AbstractQActionBiConsumer<I extends AbstractActionInput, O
     *******************************************************************************/
    public Future<Void> executeAsync(I input, O output)
    {
+      CapturedContext         capturedContext   = QContext.capture();
       CompletableFuture<Void> completableFuture = new CompletableFuture<>();
       Executors.newCachedThreadPool().submit(() ->
       {
          try
          {
+            QContext.init(capturedContext);
             execute(input, output);
             completableFuture.complete(null);
          }
@@ -62,6 +66,10 @@ public abstract class AbstractQActionBiConsumer<I extends AbstractActionInput, O
          {
             completableFuture.completeExceptionally(e);
          }
+         finally
+         {
+            QContext.clear();
+         }
       });
       return (completableFuture);
    }

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

@@ -25,6 +25,8 @@ package com.kingsrook.qqq.backend.core.actions;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
+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.actions.AbstractActionInput;
 import com.kingsrook.qqq.backend.core.model.actions.AbstractActionOutput;
@@ -50,11 +52,13 @@ public abstract class AbstractQActionFunction<I extends AbstractActionInput, O e
     *******************************************************************************/
    public Future<O> executeAsync(I input)
    {
+      CapturedContext      capturedContext   = QContext.capture();
       CompletableFuture<O> completableFuture = new CompletableFuture<>();
       Executors.newCachedThreadPool().submit(() ->
       {
          try
          {
+            QContext.init(capturedContext);
             O output = execute(input);
             completableFuture.complete(output);
          }
@@ -62,6 +66,10 @@ public abstract class AbstractQActionFunction<I extends AbstractActionInput, O e
          {
             completableFuture.completeExceptionally(e);
          }
+         finally
+         {
+            QContext.clear();
+         }
       });
       return (completableFuture);
    }

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

@@ -25,9 +25,12 @@ package com.kingsrook.qqq.backend.core.actions;
 import java.io.Serializable;
 import java.util.List;
 import java.util.function.Function;
+import com.kingsrook.qqq.backend.core.context.QContext;
 import com.kingsrook.qqq.backend.core.exceptions.QAuthenticationException;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
 import com.kingsrook.qqq.backend.core.model.actions.AbstractActionInput;
+import com.kingsrook.qqq.backend.core.model.metadata.QInstance;
+import com.kingsrook.qqq.backend.core.model.session.QSession;
 import com.kingsrook.qqq.backend.core.modules.authentication.QAuthenticationModuleDispatcher;
 import com.kingsrook.qqq.backend.core.modules.authentication.QAuthenticationModuleInterface;
 
@@ -43,9 +46,22 @@ public class ActionHelper
     *******************************************************************************/
    public static void validateSession(AbstractActionInput request) throws QException
    {
+      QInstance qInstance = QContext.getQInstance();
+      QSession  qSession  = QContext.getQSession();
+
+      if(qInstance == null)
+      {
+         throw (new QException("QInstance was not set in QContext."));
+      }
+
+      if(qSession == null)
+      {
+         throw (new QException("QSession was not set in QContext."));
+      }
+
       QAuthenticationModuleDispatcher qAuthenticationModuleDispatcher = new QAuthenticationModuleDispatcher();
-      QAuthenticationModuleInterface  authenticationModule            = qAuthenticationModuleDispatcher.getQModule(request.getAuthenticationMetaData());
-      if(!authenticationModule.isSessionValid(request.getInstance(), request.getSession()))
+      QAuthenticationModuleInterface  authenticationModule            = qAuthenticationModuleDispatcher.getQModule(qInstance.getAuthentication());
+      if(!authenticationModule.isSessionValid(qInstance, qSession))
       {
          throw new QAuthenticationException("Invalid session in request");
       }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/async/AsyncJobCallback.java

@@ -95,6 +95,23 @@ public class AsyncJobCallback
 
 
 
+   /*******************************************************************************
+    ** Update the current and total fields, but ONLY if the new values are
+    ** both >= the previous values.
+    *******************************************************************************/
+   public void updateStatusOnlyUpwards(int current, int total)
+   {
+      boolean currentIsOkay = (this.asyncJobStatus.getCurrent() == null || this.asyncJobStatus.getCurrent() <= current);
+      boolean totalIsOkay   = (this.asyncJobStatus.getTotal() == null || this.asyncJobStatus.getTotal() <= total);
+
+      if(currentIsOkay && totalIsOkay)
+      {
+         updateStatus(current, total);
+      }
+   }
+
+
+
    /*******************************************************************************
     ** Increase the 'current' value in the '1 of 2' sense.
     *******************************************************************************/

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/async/AsyncJobManager.java

@@ -30,13 +30,18 @@ import java.util.concurrent.CompletionException;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
+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.exceptions.QUserFacingException;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
 import com.kingsrook.qqq.backend.core.state.InMemoryStateProvider;
 import com.kingsrook.qqq.backend.core.state.StateProviderInterface;
 import com.kingsrook.qqq.backend.core.state.StateType;
 import com.kingsrook.qqq.backend.core.state.UUIDAndTypeStateKey;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
+import com.kingsrook.qqq.backend.core.utils.StringUtils;
+import org.apache.logging.log4j.Level;
+import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
 
 
 /*******************************************************************************
@@ -44,8 +49,9 @@ import org.apache.logging.log4j.Logger;
  *******************************************************************************/
 public class AsyncJobManager
 {
-   private static final Logger LOG = LogManager.getLogger(AsyncJobManager.class);
+   private static final QLogger LOG = QLogger.getLogger(AsyncJobManager.class);
 
+   private String forcedJobUUID = null;
 
 
    /*******************************************************************************
@@ -65,15 +71,18 @@ public class AsyncJobManager
     *******************************************************************************/
    public <T extends Serializable> T startJob(String jobName, long timeout, TimeUnit timeUnit, AsyncJob<T> asyncJob) throws JobGoingAsyncException, QException
    {
-      UUIDAndTypeStateKey uuidAndTypeStateKey = new UUIDAndTypeStateKey(UUID.randomUUID(), StateType.ASYNC_JOB_STATUS);
+      UUID                jobUUID             = StringUtils.hasContent(forcedJobUUID) ? UUID.fromString(forcedJobUUID) : UUID.randomUUID();
+      UUIDAndTypeStateKey uuidAndTypeStateKey = new UUIDAndTypeStateKey(jobUUID, StateType.ASYNC_JOB_STATUS);
       AsyncJobStatus      asyncJobStatus      = new AsyncJobStatus();
       asyncJobStatus.setState(AsyncJobState.RUNNING);
       getStateProvider().put(uuidAndTypeStateKey, asyncJobStatus);
 
       try
       {
+         CapturedContext capturedContext = QContext.capture();
          CompletableFuture<T> future = CompletableFuture.supplyAsync(() ->
          {
+            QContext.init(capturedContext);
             return (runAsyncJob(jobName, asyncJob, uuidAndTypeStateKey, asyncJobStatus));
          });
 
@@ -147,12 +156,17 @@ public class AsyncJobManager
          asyncJobStatus.setState(AsyncJobState.ERROR);
          asyncJobStatus.setCaughtException(e);
          getStateProvider().put(uuidAndTypeStateKey, asyncJobStatus);
-         LOG.warn("Job " + uuidAndTypeStateKey.getUuid() + " ended with an exception: ", e);
+
+         //////////////////////////////////////////////////////
+         // if user facing, just log an info, warn otherwise //
+         //////////////////////////////////////////////////////
+         LOG.log((e instanceof QUserFacingException) ? Level.INFO : Level.WARN, "Job ended with an exception", e, logPair("jobId", uuidAndTypeStateKey.getUuid()));
          throw (new CompletionException(e));
       }
       finally
       {
          Thread.currentThread().setName(originalThreadName);
+         QContext.clear();
       }
    }
 
@@ -194,4 +208,35 @@ public class AsyncJobManager
       jobStatus.ifPresent(asyncJobStatus -> asyncJobStatus.setCancelRequested(true));
    }
 
+
+
+   /*******************************************************************************
+    ** Getter for forcedJobUUID
+    *******************************************************************************/
+   public String getForcedJobUUID()
+   {
+      return (this.forcedJobUUID);
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for forcedJobUUID
+    *******************************************************************************/
+   public void setForcedJobUUID(String forcedJobUUID)
+   {
+      this.forcedJobUUID = forcedJobUUID;
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for forcedJobUUID
+    *******************************************************************************/
+   public AsyncJobManager withForcedJobUUID(String forcedJobUUID)
+   {
+      this.forcedJobUUID = forcedJobUUID;
+      return (this);
+   }
+
 }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/async/AsyncRecordPipeLoop.java

@@ -25,11 +25,13 @@ package com.kingsrook.qqq.backend.core.actions.async;
 import java.io.Serializable;
 import java.util.Optional;
 import java.util.concurrent.TimeUnit;
+import com.kingsrook.qqq.backend.core.actions.reporting.BufferedRecordPipe;
 import com.kingsrook.qqq.backend.core.actions.reporting.RecordPipe;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
 import com.kingsrook.qqq.backend.core.utils.SleepUtils;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
+import com.kingsrook.qqq.backend.core.utils.lambdas.UnsafeFunction;
+import com.kingsrook.qqq.backend.core.utils.lambdas.UnsafeSupplier;
 
 
 /*******************************************************************************
@@ -40,13 +42,14 @@ import org.apache.logging.log4j.Logger;
  *******************************************************************************/
 public class AsyncRecordPipeLoop
 {
-   private static final Logger LOG = LogManager.getLogger(AsyncRecordPipeLoop.class);
+   private static final QLogger LOG = QLogger.getLogger(AsyncRecordPipeLoop.class);
 
    private static final int TIMEOUT_AFTER_NO_RECORDS_MS = 10 * 60 * 1000;
 
-   private static final int MAX_SLEEP_MS           = 1000;
-   private static final int INIT_SLEEP_MS          = 10;
-   private static final int MIN_RECORDS_TO_CONSUME = 10;
+   private static final int MAX_SLEEP_MS  = 1000;
+   private static final int INIT_SLEEP_MS = 10;
+
+   private Integer minRecordsToConsume = 10;
 
 
 
@@ -62,7 +65,7 @@ public class AsyncRecordPipeLoop
     ** @param consumer lambda that consumes records from the pipe
     *                  e.g., a transform/load step.
     *******************************************************************************/
-   public int run(String jobName, Integer recordLimit, RecordPipe recordPipe, UnsafeFunction<AsyncJobCallback, ? extends Serializable> supplier, UnsafeSupplier<Integer> consumer) throws QException
+   public int run(String jobName, Integer recordLimit, RecordPipe recordPipe, UnsafeFunction<AsyncJobCallback, ? extends Serializable, QException> supplier, UnsafeSupplier<Integer, QException> consumer) throws QException
    {
       ///////////////////////////////////////////////////
       // start the extraction function as an async job //
@@ -82,7 +85,7 @@ public class AsyncRecordPipeLoop
 
       while(jobState.equals(AsyncJobState.RUNNING))
       {
-         if(recordPipe.countAvailableRecords() < MIN_RECORDS_TO_CONSUME)
+         if(recordPipe.countAvailableRecords() < minRecordsToConsume)
          {
             ///////////////////////////////////////////////////////////////
             // if the pipe is too empty, sleep to let the producer work. //
@@ -140,6 +143,11 @@ public class AsyncRecordPipeLoop
          jobState = asyncJobStatus.getState();
       }
 
+      if(recordPipe instanceof BufferedRecordPipe bufferedRecordPipe)
+      {
+         bufferedRecordPipe.finalFlush();
+      }
+
       LOG.debug("Job [" + jobUUID + "][" + jobName + "] completed with status: " + asyncJobStatus);
 
       ///////////////////////////////////
@@ -178,29 +186,32 @@ public class AsyncRecordPipeLoop
 
 
    /*******************************************************************************
-    **
+    ** Getter for minRecordsToConsume
     *******************************************************************************/
-   @FunctionalInterface
-   public interface UnsafeFunction<T, R>
+   public Integer getMinRecordsToConsume()
    {
-      /*******************************************************************************
-       **
-       *******************************************************************************/
-      R apply(T t) throws QException;
+      return (this.minRecordsToConsume);
    }
 
 
 
    /*******************************************************************************
-    **
+    ** Setter for minRecordsToConsume
     *******************************************************************************/
-   @FunctionalInterface
-   public interface UnsafeSupplier<T>
+   public void setMinRecordsToConsume(Integer minRecordsToConsume)
    {
-      /*******************************************************************************
-       **
-       *******************************************************************************/
-      T get() throws QException;
+      this.minRecordsToConsume = minRecordsToConsume;
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for minRecordsToConsume
+    *******************************************************************************/
+   public AsyncRecordPipeLoop withMinRecordsToConsume(Integer minRecordsToConsume)
+   {
+      this.minRecordsToConsume = minRecordsToConsume;
+      return (this);
    }
 
 }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/audits/AuditAction.java

@@ -0,0 +1,406 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2023.  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.audits;
+
+
+import java.io.Serializable;
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import com.kingsrook.qqq.backend.core.actions.AbstractQActionFunction;
+import com.kingsrook.qqq.backend.core.actions.tables.GetAction;
+import com.kingsrook.qqq.backend.core.actions.tables.InsertAction;
+import com.kingsrook.qqq.backend.core.context.QContext;
+import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
+import com.kingsrook.qqq.backend.core.model.actions.audits.AuditInput;
+import com.kingsrook.qqq.backend.core.model.actions.audits.AuditOutput;
+import com.kingsrook.qqq.backend.core.model.actions.audits.AuditSingleInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.get.GetInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.get.GetOutput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.insert.InsertInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.insert.InsertOutput;
+import com.kingsrook.qqq.backend.core.model.data.QRecord;
+import com.kingsrook.qqq.backend.core.model.metadata.security.RecordSecurityLock;
+import com.kingsrook.qqq.backend.core.model.metadata.security.RecordSecurityLockFilters;
+import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
+import com.kingsrook.qqq.backend.core.model.session.QUser;
+import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
+import com.kingsrook.qqq.backend.core.utils.Pair;
+import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
+
+
+/*******************************************************************************
+ ** Insert 1 or more audits (and optionally their children, auditDetails)
+ **
+ ** Takes care of managing the foreign key tables (auditTable, auditUser).
+ **
+ ** Enforces that security key values are provided, if the table has any.  Note that
+ ** might mean a null is given for a particular key, but at least the key must be present.
+ *******************************************************************************/
+public class AuditAction extends AbstractQActionFunction<AuditInput, AuditOutput>
+{
+   private static final QLogger LOG = QLogger.getLogger(AuditAction.class);
+
+   private Map<Pair<String, String>, Integer> cachedFetches = new HashMap<>();
+
+
+
+   /*******************************************************************************
+    ** Execute to insert 1 audit, with no details (child records)
+    *******************************************************************************/
+   public static void execute(String tableName, Integer recordId, Map<String, Serializable> securityKeyValues, String message)
+   {
+      execute(tableName, recordId, securityKeyValues, message, null);
+   }
+
+
+
+   /*******************************************************************************
+    ** Execute to insert 1 audit, with a list of detail child records provided as just string messages
+    *******************************************************************************/
+   public static void executeWithStringDetails(String tableName, Integer recordId, Map<String, Serializable> securityKeyValues, String message, List<String> detailMessages)
+   {
+      List<QRecord> detailRecords = null;
+      if(CollectionUtils.nullSafeHasContents(detailMessages))
+      {
+         detailRecords = detailMessages.stream().map(m -> new QRecord().withValue("message", m)).toList();
+      }
+      execute(tableName, recordId, securityKeyValues, message, detailRecords);
+   }
+
+
+
+   /*******************************************************************************
+    ** Execute to insert 1 audit, with a list of detail child records
+    *******************************************************************************/
+   public static void execute(String tableName, Integer recordId, Map<String, Serializable> securityKeyValues, String message, List<QRecord> details)
+   {
+      new AuditAction().execute(new AuditInput().withAuditSingleInput(new AuditSingleInput()
+         .withAuditTableName(tableName)
+         .withRecordId(recordId)
+         .withSecurityKeyValues(securityKeyValues)
+         .withMessage(message)
+         .withDetails(details)
+      ));
+   }
+
+
+
+   /*******************************************************************************
+    ** Simple overload that internally figures out primary key and security key values
+    **
+    ** Be aware - if the record doesn't have its security key values set (say it's a
+    ** partial record as part of an update), then those values won't be in the
+    ** security key map...  This should probably be considered a bug.
+    *******************************************************************************/
+   public static void appendToInput(AuditInput auditInput, QTableMetaData table, QRecord record, String auditMessage)
+   {
+      appendToInput(auditInput, table.getName(), record.getValueInteger(table.getPrimaryKeyField()), getRecordSecurityKeyValues(table, record, Optional.empty()), auditMessage);
+   }
+
+
+
+   /*******************************************************************************
+    ** Add 1 auditSingleInput to an AuditInput object - with no details (child records).
+    *******************************************************************************/
+   public static void appendToInput(AuditInput auditInput, String tableName, Integer recordId, Map<String, Serializable> securityKeyValues, String message)
+   {
+      appendToInput(auditInput, tableName, recordId, securityKeyValues, message, null);
+   }
+
+
+
+   /*******************************************************************************
+    ** Add 1 auditSingleInput to an AuditInput object - with a list of details (child records).
+    *******************************************************************************/
+   public static AuditInput appendToInput(AuditInput auditInput, String tableName, Integer recordId, Map<String, Serializable> securityKeyValues, String message, List<QRecord> details)
+   {
+      if(auditInput == null)
+      {
+         auditInput = new AuditInput();
+      }
+
+      return auditInput.withAuditSingleInput(new AuditSingleInput()
+         .withAuditTableName(tableName)
+         .withRecordId(recordId)
+         .withSecurityKeyValues(securityKeyValues)
+         .withMessage(message)
+         .withDetails(details)
+      );
+   }
+
+
+
+   /*******************************************************************************
+    ** For a given record, from a given table, build a map of the record's security
+    ** key values.
+    **
+    ** If, in case, the record has null value(s), and the oldRecord is given (e.g.,
+    ** for the case of an update, where the record may not have all fields set, and
+    ** oldRecord should be known for doing field-diffs), then try to get the value(s)
+    ** from oldRecord.
+    **
+    ** Currently, will leave values null if they aren't found after that.
+    **
+    ** An alternative could be to re-fetch the record from its source if needed...
+    *******************************************************************************/
+   public static Map<String, Serializable> getRecordSecurityKeyValues(QTableMetaData table, QRecord record, Optional<QRecord> oldRecord)
+   {
+      Map<String, Serializable> securityKeyValues = new HashMap<>();
+      for(RecordSecurityLock recordSecurityLock : RecordSecurityLockFilters.filterForReadLocks(CollectionUtils.nonNullList(table.getRecordSecurityLocks())))
+      {
+         Serializable keyValue = record == null ? null : record.getValue(recordSecurityLock.getFieldName());
+
+         if(keyValue == null && oldRecord.isPresent())
+         {
+            LOG.debug("Table with a securityLock, but value not found in field", logPair("table", table.getName()), logPair("field", recordSecurityLock.getFieldName()));
+            keyValue = oldRecord.get().getValue(recordSecurityLock.getFieldName());
+         }
+
+         if(keyValue == null)
+         {
+            LOG.debug("Table with a securityLock, but value not found in field", logPair("table", table.getName()), logPair("field", recordSecurityLock.getFieldName()), logPair("oldRecordIsPresent", oldRecord.isPresent()));
+         }
+
+         securityKeyValues.put(recordSecurityLock.getSecurityKeyType(), keyValue);
+      }
+      return securityKeyValues;
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Override
+   public AuditOutput execute(AuditInput input)
+   {
+      AuditOutput auditOutput = new AuditOutput();
+
+      if(CollectionUtils.nullSafeHasContents(input.getAuditSingleInputList()))
+      {
+         try
+         {
+            List<QRecord> auditRecords = new ArrayList<>();
+
+            for(AuditSingleInput auditSingleInput : CollectionUtils.nonNullList(input.getAuditSingleInputList()))
+            {
+               /////////////////////////////////////////
+               // validate table is known in instance //
+               /////////////////////////////////////////
+               QTableMetaData table = QContext.getQInstance().getTable(auditSingleInput.getAuditTableName());
+               if(table == null)
+               {
+                  throw (new QException("Requested audit for an unrecognized table name: " + auditSingleInput.getAuditTableName()));
+               }
+
+               ///////////////////////////////////////////////////
+               // validate security keys on the table are given //
+               ///////////////////////////////////////////////////
+               for(RecordSecurityLock recordSecurityLock : RecordSecurityLockFilters.filterForReadLocks(CollectionUtils.nonNullList(table.getRecordSecurityLocks())))
+               {
+                  if(auditSingleInput.getSecurityKeyValues() == null || !auditSingleInput.getSecurityKeyValues().containsKey(recordSecurityLock.getSecurityKeyType()))
+                  {
+                     throw (new QException("Missing securityKeyValue [" + recordSecurityLock.getSecurityKeyType() + "] in audit request for table " + auditSingleInput.getAuditTableName()));
+                  }
+               }
+
+               ////////////////////////////////////////////////
+               // map names to ids and handle default values //
+               ////////////////////////////////////////////////
+               Integer auditTableId = getIdForName("auditTable", auditSingleInput.getAuditTableName());
+               Integer auditUserId  = getIdForName("auditUser", Objects.requireNonNullElse(auditSingleInput.getAuditUserName(), getSessionUserName()));
+               Instant timestamp    = Objects.requireNonNullElse(auditSingleInput.getTimestamp(), Instant.now());
+
+               //////////////////
+               // build record //
+               //////////////////
+               QRecord record = new QRecord()
+                  .withValue("auditTableId", auditTableId)
+                  .withValue("auditUserId", auditUserId)
+                  .withValue("timestamp", timestamp)
+                  .withValue("message", auditSingleInput.getMessage())
+                  .withValue("recordId", auditSingleInput.getRecordId());
+
+               if(auditSingleInput.getSecurityKeyValues() != null)
+               {
+                  for(Map.Entry<String, Serializable> entry : auditSingleInput.getSecurityKeyValues().entrySet())
+                  {
+                     record.setValue(entry.getKey(), entry.getValue());
+                  }
+               }
+
+               auditRecords.add(record);
+            }
+
+            /////////////////////////////
+            // do a single bulk insert //
+            /////////////////////////////
+            InsertInput insertInput = new InsertInput();
+            insertInput.setTableName("audit");
+            insertInput.setRecords(auditRecords);
+            InsertOutput insertOutput = new InsertAction().execute(insertInput);
+
+            //////////////////////////////////////////
+            // now look for children (auditDetails) //
+            //////////////////////////////////////////
+            int           i                  = 0;
+            List<QRecord> auditDetailRecords = new ArrayList<>();
+            for(AuditSingleInput auditSingleInput : CollectionUtils.nonNullList(input.getAuditSingleInputList()))
+            {
+               Integer auditId = insertOutput.getRecords().get(i++).getValueInteger("id");
+               if(auditId == null)
+               {
+                  LOG.warn("Missing an id for inserted audit - so won't be able to store its child details...");
+                  continue;
+               }
+
+               for(QRecord detail : CollectionUtils.nonNullList(auditSingleInput.getDetails()))
+               {
+                  auditDetailRecords.add(detail.withValue("auditId", auditId));
+               }
+            }
+
+            if(!auditDetailRecords.isEmpty())
+            {
+               insertInput = new InsertInput();
+               insertInput.setTableName("auditDetail");
+               insertInput.setRecords(auditDetailRecords);
+               new InsertAction().execute(insertInput);
+            }
+         }
+         catch(Exception e)
+         {
+            LOG.error("Error performing an audit", e);
+         }
+      }
+
+      return (auditOutput);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private static String getSessionUserName()
+   {
+      QUser user = QContext.getQSession().getUser();
+      if(user == null)
+      {
+         return ("Unknown");
+      }
+      return (user.getFullName());
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private Integer getIdForName(String tableName, String nameValue) throws QException
+   {
+      Pair<String, String> key = new Pair<>(tableName, nameValue);
+      if(!cachedFetches.containsKey(key))
+      {
+
+         Integer id = fetchIdFromName(tableName, nameValue);
+         if(id != null)
+         {
+            cachedFetches.put(key, id);
+            return id;
+         }
+
+         try
+         {
+            LOG.debug("Inserting " + tableName + " named " + nameValue);
+            InsertInput insertInput = new InsertInput();
+            insertInput.setTableName(tableName);
+            QRecord record = new QRecord().withValue("name", nameValue);
+
+            if(tableName.equals("auditTable"))
+            {
+               QTableMetaData table = QContext.getQInstance().getTable(nameValue);
+               if(table != null)
+               {
+                  record.setValue("label", table.getLabel());
+               }
+            }
+
+            insertInput.setRecords(List.of(record));
+            InsertOutput insertOutput = new InsertAction().execute(insertInput);
+            id = insertOutput.getRecords().get(0).getValueInteger("id");
+            if(id != null)
+            {
+               cachedFetches.put(key, id);
+               return id;
+            }
+         }
+         catch(Exception e)
+         {
+            ////////////////////////////////////////////////////////////////////
+            // assume this may mean a dupe-key - so - try another fetch below //
+            ////////////////////////////////////////////////////////////////////
+            LOG.debug("Caught error inserting " + tableName + " named " + nameValue + " - will try to re-fetch", e);
+         }
+
+         id = fetchIdFromName(tableName, nameValue);
+         if(id != null)
+         {
+            cachedFetches.put(key, id);
+            return id;
+         }
+
+         /////////////
+         // give up //
+         /////////////
+         throw (new QException("Unable to get id for " + tableName + " named " + nameValue));
+      }
+
+      return (cachedFetches.get(key));
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private Integer fetchIdFromName(String tableName, String nameValue) throws QException
+   {
+      GetInput getInput = new GetInput();
+      getInput.setTableName(tableName);
+      getInput.setUniqueKey(Map.of("name", nameValue));
+      GetOutput getOutput = new GetAction().execute(getInput);
+      if(getOutput.getRecord() != null)
+      {
+         return (getOutput.getRecord().getValueInteger("id"));
+      }
+
+      return (null);
+   }
+
+}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/audits/DMLAuditAction.java

@@ -0,0 +1,556 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2023.  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.audits;
+
+
+import java.io.Serializable;
+import java.math.BigDecimal;
+import java.time.Instant;
+import java.time.ZoneId;
+import java.time.temporal.ChronoUnit;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import com.kingsrook.qqq.backend.core.actions.AbstractQActionFunction;
+import com.kingsrook.qqq.backend.core.actions.values.QPossibleValueTranslator;
+import com.kingsrook.qqq.backend.core.actions.values.QValueFormatter;
+import com.kingsrook.qqq.backend.core.context.QContext;
+import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
+import com.kingsrook.qqq.backend.core.model.actions.AbstractActionInput;
+import com.kingsrook.qqq.backend.core.model.actions.AbstractTableActionInput;
+import com.kingsrook.qqq.backend.core.model.actions.audits.AuditInput;
+import com.kingsrook.qqq.backend.core.model.actions.audits.DMLAuditInput;
+import com.kingsrook.qqq.backend.core.model.actions.audits.DMLAuditOutput;
+import com.kingsrook.qqq.backend.core.model.actions.processes.RunProcessInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.delete.DeleteInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.insert.InsertInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.update.UpdateInput;
+import com.kingsrook.qqq.backend.core.model.data.QRecord;
+import com.kingsrook.qqq.backend.core.model.metadata.audits.AuditLevel;
+import com.kingsrook.qqq.backend.core.model.metadata.fields.QFieldMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.fields.QFieldType;
+import com.kingsrook.qqq.backend.core.model.metadata.processes.QProcessMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
+import com.kingsrook.qqq.backend.core.model.session.QSession;
+import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
+import com.kingsrook.qqq.backend.core.utils.StringUtils;
+import com.kingsrook.qqq.backend.core.utils.ValueUtils;
+import static com.kingsrook.qqq.backend.core.actions.audits.AuditAction.getRecordSecurityKeyValues;
+import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
+
+
+/*******************************************************************************
+ ** Audit for a standard DML (Data Manipulation Language) activity - e.g.,
+ ** insert, edit, or delete.
+ *******************************************************************************/
+public class DMLAuditAction extends AbstractQActionFunction<DMLAuditInput, DMLAuditOutput>
+{
+   private static final QLogger LOG = QLogger.getLogger(DMLAuditAction.class);
+
+   public static final String AUDIT_CONTEXT_FIELD_NAME = "auditContext";
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Override
+   public DMLAuditOutput execute(DMLAuditInput input) throws QException
+   {
+      DMLAuditOutput           output           = new DMLAuditOutput();
+      AbstractTableActionInput tableActionInput = input.getTableActionInput();
+      List<QRecord>            oldRecordList    = input.getOldRecordList();
+      QTableMetaData           table            = tableActionInput.getTable();
+      long                     start            = System.currentTimeMillis();
+      DMLType                  dmlType          = getDMLType(tableActionInput);
+
+      try
+      {
+         List<QRecord> recordList = CollectionUtils.nonNullList(input.getRecordList()).stream()
+            .filter(r -> CollectionUtils.nullSafeIsEmpty(r.getErrors())).toList();
+
+         AuditLevel auditLevel = getAuditLevel(tableActionInput);
+         if(auditLevel == null || auditLevel.equals(AuditLevel.NONE) || CollectionUtils.nullSafeIsEmpty(recordList))
+         {
+            /////////////////////////////////////////////
+            // return with noop for null or level NONE //
+            /////////////////////////////////////////////
+            return (output);
+         }
+
+         String contextSuffix = getContentSuffix(input);
+
+         AuditInput auditInput = new AuditInput();
+         if(auditLevel.equals(AuditLevel.RECORD) || (auditLevel.equals(AuditLevel.FIELD) && !dmlType.supportsFields))
+         {
+            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
+            // make many simple audits (no details) for RECORD level                                                  //
+            // or for FIELD level, but on a DML type that doesn't support field-level details (e.g., DELETE or OTHER) //
+            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
+            for(QRecord record : recordList)
+            {
+               AuditAction.appendToInput(auditInput, table.getName(), record.getValueInteger(table.getPrimaryKeyField()), getRecordSecurityKeyValues(table, record, Optional.empty()), "Record was " + dmlType.pastTenseVerb + contextSuffix);
+            }
+         }
+         else if(auditLevel.equals(AuditLevel.FIELD))
+         {
+            Map<Serializable, QRecord> oldRecordMap = buildOldRecordMap(table, oldRecordList);
+
+            ///////////////////////////////////////////////////////////////////
+            // do many audits, all with field level details, for FIELD level //
+            ///////////////////////////////////////////////////////////////////
+            QPossibleValueTranslator qPossibleValueTranslator = new QPossibleValueTranslator(QContext.getQInstance(), QContext.getQSession());
+            qPossibleValueTranslator.translatePossibleValuesInRecords(table, CollectionUtils.mergeLists(recordList, oldRecordList));
+
+            //////////////////////////////////////////
+            // sort the field names by their labels //
+            //////////////////////////////////////////
+            List<String> sortedFieldNames = table.getFields().keySet().stream()
+               .sorted(Comparator.comparing(fieldName -> table.getFields().get(fieldName).getLabel()))
+               .toList();
+
+            QFieldMetaData primaryKeyField = table.getField(table.getPrimaryKeyField());
+
+            //////////////////////////////////////////////
+            // build single audit input for each record //
+            //////////////////////////////////////////////
+            for(QRecord record : recordList)
+            {
+               QRecord oldRecord = oldRecordMap.get(ValueUtils.getValueAsFieldType(primaryKeyField.getType(), record.getValue(primaryKeyField.getName())));
+
+               List<QRecord> details = new ArrayList<>();
+               for(String fieldName : sortedFieldNames)
+               {
+                  makeAuditDetailRecordForField(fieldName, table, dmlType, record, oldRecord)
+                     .ifPresent(details::add);
+               }
+
+               if(details.isEmpty() && DMLType.UPDATE.equals(dmlType))
+               {
+                  // no, let's just noop.
+                  // details.add(new QRecord().withValue("message", "No fields values were changed."));
+               }
+               else
+               {
+                  AuditAction.appendToInput(auditInput, table.getName(), record.getValueInteger(table.getPrimaryKeyField()), getRecordSecurityKeyValues(table, record, Optional.ofNullable(oldRecord)), "Record was " + dmlType.pastTenseVerb + contextSuffix, details);
+               }
+            }
+         }
+
+         // new AuditAction().executeAsync(auditInput); // todo async??? maybe get that from rules???
+         new AuditAction().execute(auditInput);
+         long end = System.currentTimeMillis();
+         LOG.trace("Audit performance", logPair("auditLevel", String.valueOf(auditLevel)), logPair("recordCount", recordList.size()), logPair("millis", (end - start)));
+      }
+      catch(Exception e)
+      {
+         LOG.error("Error performing DML audit", e, logPair("type", String.valueOf(dmlType)), logPair("table", table.getName()));
+      }
+
+      return (output);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   static String getContentSuffix(DMLAuditInput input)
+   {
+      StringBuilder contextSuffix = new StringBuilder();
+
+      /////////////////////////////////////////////////////////////////////////////
+      // start with context from the input wrapper                               //
+      // note, these contexts get propagated down from Input/Update/Delete Input //
+      /////////////////////////////////////////////////////////////////////////////
+      if(StringUtils.hasContent(input.getAuditContext()))
+      {
+         contextSuffix.append(" ").append(input.getAuditContext());
+      }
+
+      /////////////////////////////////////////////////////////////////////////////////////
+      // note process label (and a possible context from the process's state) if present //
+      /////////////////////////////////////////////////////////////////////////////////////
+      Optional<AbstractActionInput> actionInput = QContext.getFirstActionInStack();
+      if(actionInput.isPresent() && actionInput.get() instanceof RunProcessInput runProcessInput)
+      {
+         String processAuditContext = ValueUtils.getValueAsString(runProcessInput.getValue(AUDIT_CONTEXT_FIELD_NAME));
+         if(StringUtils.hasContent(processAuditContext))
+         {
+            contextSuffix.append(" ").append(processAuditContext);
+         }
+
+         String           processName = runProcessInput.getProcessName();
+         QProcessMetaData process     = QContext.getQInstance().getProcess(processName);
+         if(process != null)
+         {
+            contextSuffix.append(" during process: ").append(process.getLabel());
+         }
+      }
+
+      ///////////////////////////////////////////////////
+      // use api label & version if present in session //
+      ///////////////////////////////////////////////////
+      QSession qSession   = QContext.getQSession();
+      String   apiVersion = qSession.getValue("apiVersion");
+      if(apiVersion != null)
+      {
+         String apiLabel = qSession.getValue("apiLabel");
+         if(!StringUtils.hasContent(apiLabel))
+         {
+            apiLabel = "API";
+         }
+         contextSuffix.append(" via ").append(apiLabel).append(" Version: ").append(apiVersion);
+      }
+      return (contextSuffix.toString());
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   static Optional<QRecord> makeAuditDetailRecordForField(String fieldName, QTableMetaData table, DMLType dmlType, QRecord record, QRecord oldRecord)
+   {
+      if(!record.getValues().containsKey(fieldName))
+      {
+         ////////////////////////////////////////////////////////////////////////////////////////////////
+         // if the stored record doesn't have this field name, then don't audit anything about it      //
+         // this is to deal with our Patch style updates not looking like every field was cleared out. //
+         ////////////////////////////////////////////////////////////////////////////////////////////////
+         return (Optional.empty());
+      }
+
+      if(fieldName.equals("modifyDate") || fieldName.equals("createDate") || fieldName.equals("automationStatus"))
+      {
+         return (Optional.empty());
+      }
+
+      QFieldMetaData field        = table.getField(fieldName);
+      Serializable   value        = ValueUtils.getValueAsFieldType(field.getType(), record.getValue(fieldName));
+      Serializable   oldValue     = oldRecord == null ? null : ValueUtils.getValueAsFieldType(field.getType(), oldRecord.getValue(fieldName));
+      QRecord        detailRecord = null;
+
+      if(oldRecord == null)
+      {
+         if(DMLType.INSERT.equals(dmlType) && value == null)
+         {
+            return (Optional.empty());
+         }
+
+         if(field.getType().equals(QFieldType.BLOB) || field.getType().needsMasked())
+         {
+            detailRecord = new QRecord().withValue("message", "Set " + field.getLabel());
+         }
+         else
+         {
+            String formattedValue = getFormattedValueForAuditDetail(record, fieldName, field, value);
+            detailRecord = new QRecord().withValue("message", "Set " + field.getLabel() + " to " + formattedValue);
+            detailRecord.withValue("newValue", formattedValue);
+         }
+      }
+      else
+      {
+         if(areValuesDifferentForAudit(field, value, oldValue))
+         {
+            if(field.getType().equals(QFieldType.BLOB) || field.getType().needsMasked())
+            {
+               if(oldValue == null)
+               {
+                  detailRecord = new QRecord().withValue("message", "Set " + field.getLabel());
+               }
+               else if(value == null)
+               {
+                  detailRecord = new QRecord().withValue("message", "Removed " + field.getLabel());
+               }
+               else
+               {
+                  detailRecord = new QRecord().withValue("message", "Changed " + field.getLabel());
+               }
+            }
+            else
+            {
+               String formattedValue    = getFormattedValueForAuditDetail(record, fieldName, field, value);
+               String formattedOldValue = getFormattedValueForAuditDetail(oldRecord, fieldName, field, oldValue);
+
+               if(oldValue == null)
+               {
+                  detailRecord = new QRecord().withValue("message", "Set " + field.getLabel() + " to " + formatFormattedValueForDetailMessage(field, formattedValue));
+                  detailRecord.withValue("newValue", formattedValue);
+               }
+               else if(value == null)
+               {
+                  detailRecord = new QRecord().withValue("message", "Removed " + formatFormattedValueForDetailMessage(field, formattedOldValue) + " from " + field.getLabel());
+                  detailRecord.withValue("oldValue", formattedOldValue);
+               }
+               else
+               {
+                  detailRecord = new QRecord().withValue("message", "Changed " + field.getLabel() + " from " + formatFormattedValueForDetailMessage(field, formattedOldValue) + " to " + formatFormattedValueForDetailMessage(field, formattedValue));
+                  detailRecord.withValue("oldValue", formattedOldValue);
+                  detailRecord.withValue("newValue", formattedValue);
+               }
+            }
+         }
+      }
+
+      if(detailRecord != null)
+      {
+         LOG.debug("Returning with message: " + detailRecord.getValueString("message"));
+
+         detailRecord.withValue("fieldName", fieldName);
+         return (Optional.of(detailRecord));
+      }
+
+      return (Optional.empty());
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   static boolean areValuesDifferentForAudit(QFieldMetaData field, Serializable value, Serializable oldValue)
+   {
+      try
+      {
+         ///////////////////
+         // decimal rules //
+         ///////////////////
+         if(field.getType().equals(QFieldType.DECIMAL))
+         {
+            BigDecimal newBD = ValueUtils.getValueAsBigDecimal(value);
+            BigDecimal oldBD = ValueUtils.getValueAsBigDecimal(oldValue);
+
+            if(newBD == null && oldBD == null)
+            {
+               return (false);
+            }
+
+            if(newBD == null || oldBD == null)
+            {
+               return (true);
+            }
+
+            return (newBD.compareTo(oldBD) != 0);
+         }
+
+         ////////////////////
+         // dateTime rules //
+         ////////////////////
+         if(field.getType().equals(QFieldType.DATE_TIME))
+         {
+            Instant newI = ValueUtils.getValueAsInstant(value);
+            Instant oldI = ValueUtils.getValueAsInstant(oldValue);
+
+            if(newI == null && oldI == null)
+            {
+               return (false);
+            }
+
+            if(newI == null || oldI == null)
+            {
+               return (true);
+            }
+
+            ////////////////////////////////
+            // just compare to the second //
+            ////////////////////////////////
+            return (newI.truncatedTo(ChronoUnit.SECONDS).compareTo(oldI.truncatedTo(ChronoUnit.SECONDS)) != 0);
+         }
+
+         //////////////////
+         // string rules //
+         //////////////////
+         if(field.getType().isStringLike())
+         {
+            String newString = ValueUtils.getValueAsString(value);
+            String oldString = ValueUtils.getValueAsString(oldValue);
+
+            boolean newIsNullOrEmpty = !StringUtils.hasContent(newString);
+            boolean oldIsNullOrEmpty = !StringUtils.hasContent(oldString);
+
+            if(newIsNullOrEmpty && oldIsNullOrEmpty)
+            {
+               return (false);
+            }
+
+            if(newIsNullOrEmpty || oldIsNullOrEmpty)
+            {
+               return (true);
+            }
+
+            return (newString.compareTo(oldString) != 0);
+         }
+
+         /////////////////////////////////////
+         // default just use Objects.equals //
+         /////////////////////////////////////
+         return !Objects.equals(oldValue, value);
+      }
+      catch(Exception e)
+      {
+         LOG.debug("Error checking areValuesDifferentForAudit", e, logPair("fieldName", field.getName()), logPair("value", value), logPair("oldValue", oldValue));
+      }
+
+      ////////////////////////////////////
+      // default to something simple... //
+      ////////////////////////////////////
+      return !Objects.equals(oldValue, value);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private static String getFormattedValueForAuditDetail(QRecord record, String fieldName, QFieldMetaData field, Serializable value)
+   {
+      String formattedValue = null;
+      if(value != null)
+      {
+         if(field.getType().equals(QFieldType.DATE_TIME) && value instanceof Instant instant)
+         {
+            formattedValue = QValueFormatter.formatDateTimeWithZone(instant.atZone(ZoneId.of(Objects.requireNonNullElse(QContext.getQInstance().getDefaultTimeZoneId(), "UTC"))));
+         }
+         else if(record.getDisplayValue(fieldName) != null)
+         {
+            formattedValue = record.getDisplayValue(fieldName);
+         }
+         else
+         {
+            formattedValue = QValueFormatter.formatValue(field, value);
+         }
+      }
+
+      return formattedValue;
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private static String formatFormattedValueForDetailMessage(QFieldMetaData field, String formattedValue)
+   {
+      if(formattedValue == null || "null".equals(formattedValue))
+      {
+         formattedValue = "--";
+      }
+      else
+      {
+         if(QFieldType.STRING.equals(field.getType()) || field.getPossibleValueSourceName() != null)
+         {
+            formattedValue = '"' + formattedValue + '"';
+         }
+      }
+
+      return (formattedValue);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private Map<Serializable, QRecord> buildOldRecordMap(QTableMetaData table, List<QRecord> oldRecordList)
+   {
+      Map<Serializable, QRecord> rs = new HashMap<>();
+      for(QRecord record : CollectionUtils.nonNullList(oldRecordList))
+      {
+         rs.put(record.getValue(table.getPrimaryKeyField()), record);
+      }
+      return (rs);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private DMLType getDMLType(AbstractTableActionInput tableActionInput)
+   {
+      if(tableActionInput instanceof InsertInput)
+      {
+         return DMLType.INSERT;
+      }
+      else if(tableActionInput instanceof UpdateInput)
+      {
+         return DMLType.UPDATE;
+      }
+      else if(tableActionInput instanceof DeleteInput)
+      {
+         return DMLType.DELETE;
+      }
+      else
+      {
+         return DMLType.OTHER;
+      }
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public static AuditLevel getAuditLevel(AbstractTableActionInput tableActionInput)
+   {
+      QTableMetaData table = tableActionInput.getTable();
+      if(table.getAuditRules() == null)
+      {
+         return (AuditLevel.NONE);
+      }
+
+      return (table.getAuditRules().getAuditLevel());
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   enum DMLType
+   {
+      INSERT("Inserted", true),
+      UPDATE("Edited", true),
+      DELETE("Deleted", false),
+      OTHER("Processed", false);
+
+      private final String  pastTenseVerb;
+      private final boolean supportsFields;
+
+
+
+      /*******************************************************************************
+       **
+       *******************************************************************************/
+      DMLType(String pastTenseVerb, boolean supportsFields)
+      {
+         this.pastTenseVerb = pastTenseVerb;
+         this.supportsFields = supportsFields;
+      }
+   }
+}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/automation/RecordAutomationStatusUpdater.java

@@ -22,12 +22,20 @@
 package com.kingsrook.qqq.backend.core.actions.automation;
 
 
-import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
-import java.util.Objects;
+import com.kingsrook.qqq.backend.core.actions.tables.CountAction;
 import com.kingsrook.qqq.backend.core.actions.tables.UpdateAction;
+import com.kingsrook.qqq.backend.core.context.QContext;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
+import com.kingsrook.qqq.backend.core.model.actions.tables.count.CountInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.count.CountOutput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QCriteriaOperator;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QFilterCriteria;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QQueryFilter;
 import com.kingsrook.qqq.backend.core.model.actions.tables.update.UpdateInput;
+import com.kingsrook.qqq.backend.core.model.automation.TableTrigger;
 import com.kingsrook.qqq.backend.core.model.data.QRecord;
 import com.kingsrook.qqq.backend.core.model.metadata.QInstance;
 import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
@@ -37,7 +45,6 @@ import com.kingsrook.qqq.backend.core.model.metadata.tables.automation.TableAuto
 import com.kingsrook.qqq.backend.core.model.metadata.tables.automation.TriggerEvent;
 import com.kingsrook.qqq.backend.core.model.session.QSession;
 import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
-import com.kingsrook.qqq.backend.core.utils.QLogger;
 import org.apache.commons.lang.NotImplementedException;
 
 
@@ -76,12 +83,16 @@ public class RecordAutomationStatusUpdater
             String className = stackTraceElement.getClassName();
             if(className.contains("com.kingsrook.qqq.backend.core.actions.automation") && !className.equals(RecordAutomationStatusUpdater.class.getName()) && !className.endsWith("Test"))
             {
-               LOG.debug(session, "Avoiding re-setting automation status to PENDING_UPDATE while running an automation");
+               LOG.debug("Avoiding re-setting automation status to PENDING_UPDATE while running an automation");
                return (false);
             }
          }
       }
 
+      ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // Avoid setting records to PENDING_INSERT or PENDING_UPDATE even if they don't have any insert or update automations or triggers //
+      // such records should go straight to OK status.                                                                                  //
+      ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
       if(canWeSkipPendingAndGoToOkay(table, automationStatus))
       {
          automationStatus = AutomationStatus.OK;
@@ -113,20 +124,91 @@ public class RecordAutomationStatusUpdater
     ** being asked to set status to PENDING_INSERT (or PENDING_UPDATE), then just
     ** move the status straight to OK.
     *******************************************************************************/
-   private static boolean canWeSkipPendingAndGoToOkay(QTableMetaData table, AutomationStatus automationStatus)
+   static boolean canWeSkipPendingAndGoToOkay(QTableMetaData table, AutomationStatus automationStatus)
    {
-      List<TableAutomationAction> tableActions = Objects.requireNonNullElse(table.getAutomationDetails().getActions(), new ArrayList<>());
+      List<TableAutomationAction> tableActions = Collections.emptyList();
+      if(table.getAutomationDetails() != null && table.getAutomationDetails().getActions() != null)
+      {
+         tableActions = table.getAutomationDetails().getActions();
+      }
 
       if(automationStatus.equals(AutomationStatus.PENDING_INSERT_AUTOMATIONS))
       {
-         return tableActions.stream().noneMatch(a -> TriggerEvent.POST_INSERT.equals(a.getTriggerEvent()));
+         if(tableActions.stream().anyMatch(a -> TriggerEvent.POST_INSERT.equals(a.getTriggerEvent())))
+         {
+            return (false);
+         }
+         else if(areThereTableTriggersForTable(table, TriggerEvent.POST_INSERT))
+         {
+            return (false);
+         }
+
+         ////////////////////////////////////////////////////////////////////////////////////////
+         // if we're going to pending-insert, and there are no insert automations or triggers, //
+         // then we may skip pending and go to okay.                                           //
+         ////////////////////////////////////////////////////////////////////////////////////////
+         return (true);
       }
       else if(automationStatus.equals(AutomationStatus.PENDING_UPDATE_AUTOMATIONS))
       {
-         return tableActions.stream().noneMatch(a -> TriggerEvent.POST_UPDATE.equals(a.getTriggerEvent()));
+         if(tableActions.stream().anyMatch(a -> TriggerEvent.POST_UPDATE.equals(a.getTriggerEvent())))
+         {
+            return (false);
+         }
+         else if(areThereTableTriggersForTable(table, TriggerEvent.POST_UPDATE))
+         {
+            return (false);
+         }
+
+         ////////////////////////////////////////////////////////////////////////////////////////
+         // if we're going to pending-update, and there are no insert automations or triggers, //
+         // then we may skip pending and go to okay.                                           //
+         ////////////////////////////////////////////////////////////////////////////////////////
+         return (true);
+      }
+      else
+      {
+         ///////////////////////////////////////////////////////////////////////////////////////////////////////
+         // if we're going to any other automation status - then we may never "skip pending" and go to okay - //
+         // because we weren't asked to go to pending!                                                        //
+         ///////////////////////////////////////////////////////////////////////////////////////////////////////
+         return (false);
+      }
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private static boolean areThereTableTriggersForTable(QTableMetaData table, TriggerEvent triggerEvent)
+   {
+      if(QContext.getQInstance().getTable(TableTrigger.TABLE_NAME) == null)
+      {
+         return (false);
       }
 
-      return (false);
+      try
+      {
+         ///////////////////
+         // todo - cache? //
+         ///////////////////
+         CountInput countInput = new CountInput();
+         countInput.setTableName(TableTrigger.TABLE_NAME);
+         countInput.setFilter(new QQueryFilter(
+            new QFilterCriteria("tableName", QCriteriaOperator.EQUALS, table.getName()),
+            new QFilterCriteria(triggerEvent.equals(TriggerEvent.POST_INSERT) ? "postInsert" : "postUpdate", QCriteriaOperator.EQUALS, true)
+         ));
+         CountOutput countOutput = new CountAction().execute(countInput);
+         return (countOutput.getCount() != null && countOutput.getCount() > 0);
+      }
+      catch(Exception e)
+      {
+         ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+         // if the count query failed, we're a bit safer to err on the side of "yeah, there might be automations" //
+         ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+         return (true);
+      }
    }
 
 
@@ -143,8 +225,7 @@ public class RecordAutomationStatusUpdater
          boolean didSetStatusField = setAutomationStatusInRecords(session, table, records, automationStatus);
          if(didSetStatusField)
          {
-            UpdateInput updateInput = new UpdateInput(instance);
-            updateInput.setSession(session);
+            UpdateInput updateInput = new UpdateInput();
             updateInput.setTableName(table.getName());
 
             /////////////////////////////////////////////////////////////////////////////////////
@@ -156,6 +237,7 @@ public class RecordAutomationStatusUpdater
                .withValue(table.getPrimaryKeyField(), r.getValue(table.getPrimaryKeyField()))
                .withValue(automationDetails.getStatusTracking().getFieldName(), r.getValue(automationDetails.getStatusTracking().getFieldName()))).toList());
             updateInput.setAreAllValuesBeingUpdatedTheSame(true);
+            updateInput.setOmitDmlAudit(true);
 
             new UpdateAction().execute(updateInput);
          }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/automation/RunRecordScriptAutomationHandler.java

@@ -0,0 +1,96 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2023.  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.automation;
+
+
+import java.io.Serializable;
+import java.util.Map;
+import com.kingsrook.qqq.backend.core.actions.scripts.RunAdHocRecordScriptAction;
+import com.kingsrook.qqq.backend.core.actions.tables.QueryAction;
+import com.kingsrook.qqq.backend.core.context.QContext;
+import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
+import com.kingsrook.qqq.backend.core.model.actions.scripts.RunAdHocRecordScriptInput;
+import com.kingsrook.qqq.backend.core.model.actions.scripts.RunAdHocRecordScriptOutput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QCriteriaOperator;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QFilterCriteria;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QQueryFilter;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryJoin;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryOutput;
+import com.kingsrook.qqq.backend.core.model.automation.RecordAutomationInput;
+import com.kingsrook.qqq.backend.core.model.data.QRecord;
+import com.kingsrook.qqq.backend.core.model.metadata.code.AdHocScriptCodeReference;
+import com.kingsrook.qqq.backend.core.model.scripts.Script;
+import com.kingsrook.qqq.backend.core.model.scripts.ScriptRevision;
+import com.kingsrook.qqq.backend.core.model.scripts.ScriptsMetaDataProvider;
+import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
+import com.kingsrook.qqq.backend.core.utils.ValueUtils;
+import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
+
+
+/*******************************************************************************
+ **
+ *******************************************************************************/
+public class RunRecordScriptAutomationHandler extends RecordAutomationHandler
+{
+   private static final QLogger LOG = QLogger.getLogger(RunRecordScriptAutomationHandler.class);
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Override
+   public void execute(RecordAutomationInput recordAutomationInput) throws QException
+   {
+      String                    tableName = recordAutomationInput.getTableName();
+      Map<String, Serializable> values    = recordAutomationInput.getAction().getValues();
+      Integer                   scriptId  = ValueUtils.getValueAsInteger(values.get("scriptId"));
+
+      if(scriptId == null)
+      {
+         throw (new QException("ScriptId was not provided in values map for record automations on table: " + tableName));
+      }
+
+      QueryInput queryInput = new QueryInput();
+      queryInput.setTableName(ScriptRevision.TABLE_NAME);
+      queryInput.setFilter(new QQueryFilter(new QFilterCriteria("scriptId", QCriteriaOperator.EQUALS, scriptId)));
+      queryInput.withQueryJoin(new QueryJoin(Script.TABLE_NAME).withBaseTableOrAlias(ScriptRevision.TABLE_NAME).withJoinMetaData(QContext.getQInstance().getJoin(ScriptsMetaDataProvider.CURRENT_SCRIPT_REVISION_JOIN_NAME)));
+      QueryOutput queryOutput = new QueryAction().execute(queryInput);
+      if(CollectionUtils.nullSafeIsEmpty(queryOutput.getRecords()))
+      {
+         throw (new QException("Could not find current revision for scriptId: " + scriptId + " on table " + tableName));
+      }
+
+      QRecord scriptRevision = queryOutput.getRecords().get(0);
+      LOG.info("Running script against records", logPair("scriptRevisionId", scriptRevision.getValue("id")), logPair("scriptId", scriptRevision.getValue("scriptIdd")));
+
+      RunAdHocRecordScriptInput input = new RunAdHocRecordScriptInput();
+      input.setCodeReference(new AdHocScriptCodeReference().withScriptRevisionRecord(scriptRevision));
+      input.setTableName(tableName);
+      input.setRecordList(recordAutomationInput.getRecordList());
+      RunAdHocRecordScriptOutput output = new RunAdHocRecordScriptOutput();
+      new RunAdHocRecordScriptAction().run(input, output);
+   }
+
+}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/automation/polling/PollingAutomationPerTableRunner.java

@@ -25,43 +25,53 @@ package com.kingsrook.qqq.backend.core.actions.automation.polling;
 import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.Comparator;
-import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
 import com.kingsrook.qqq.backend.core.actions.async.AsyncRecordPipeLoop;
 import com.kingsrook.qqq.backend.core.actions.automation.AutomationStatus;
 import com.kingsrook.qqq.backend.core.actions.automation.RecordAutomationHandler;
 import com.kingsrook.qqq.backend.core.actions.automation.RecordAutomationStatusUpdater;
+import com.kingsrook.qqq.backend.core.actions.automation.RunRecordScriptAutomationHandler;
 import com.kingsrook.qqq.backend.core.actions.customizers.QCodeLoader;
 import com.kingsrook.qqq.backend.core.actions.processes.QProcessCallback;
 import com.kingsrook.qqq.backend.core.actions.processes.RunProcessAction;
 import com.kingsrook.qqq.backend.core.actions.reporting.RecordPipe;
+import com.kingsrook.qqq.backend.core.actions.tables.GetAction;
 import com.kingsrook.qqq.backend.core.actions.tables.QueryAction;
+import com.kingsrook.qqq.backend.core.context.QContext;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
 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.tables.get.GetInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.get.GetOutput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QCriteriaOperator;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QFilterCriteria;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QFilterOrderBy;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QQueryFilter;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryOutput;
 import com.kingsrook.qqq.backend.core.model.automation.RecordAutomationInput;
+import com.kingsrook.qqq.backend.core.model.automation.TableTrigger;
 import com.kingsrook.qqq.backend.core.model.data.QRecord;
 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.tables.QTableMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.tables.automation.AutomationStatusTrackingType;
 import com.kingsrook.qqq.backend.core.model.metadata.tables.automation.QTableAutomationDetails;
 import com.kingsrook.qqq.backend.core.model.metadata.tables.automation.TableAutomationAction;
 import com.kingsrook.qqq.backend.core.model.metadata.tables.automation.TriggerEvent;
+import com.kingsrook.qqq.backend.core.model.savedfilters.SavedFilter;
 import com.kingsrook.qqq.backend.core.model.session.QSession;
-import com.kingsrook.qqq.backend.core.scheduler.StandardScheduledExecutor;
 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.collections.MapBuilder;
 import org.apache.commons.lang.NotImplementedException;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
+import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
 
 
 /*******************************************************************************
@@ -75,7 +85,7 @@ import org.apache.logging.log4j.Logger;
  *******************************************************************************/
 public class PollingAutomationPerTableRunner implements Runnable
 {
-   private static final Logger LOG = LogManager.getLogger(PollingAutomationPerTableRunner.class);
+   private static final QLogger LOG = QLogger.getLogger(PollingAutomationPerTableRunner.class);
 
    private final TableActions tableActions;
    private final String       name;
@@ -88,6 +98,11 @@ public class PollingAutomationPerTableRunner implements Runnable
       TriggerEvent.POST_UPDATE, AutomationStatus.PENDING_UPDATE_AUTOMATIONS
    );
 
+   private static Map<AutomationStatus, TriggerEvent> automationStatusTriggerEventMap = Map.of(
+      AutomationStatus.PENDING_INSERT_AUTOMATIONS, TriggerEvent.POST_INSERT,
+      AutomationStatus.PENDING_UPDATE_AUTOMATIONS, TriggerEvent.POST_UPDATE
+   );
+
    private static Map<AutomationStatus, AutomationStatus> pendingToRunningStatusMap = Map.of(
       AutomationStatus.PENDING_INSERT_AUTOMATIONS, AutomationStatus.RUNNING_INSERT_AUTOMATIONS,
       AutomationStatus.PENDING_UPDATE_AUTOMATIONS, AutomationStatus.RUNNING_UPDATE_AUTOMATIONS
@@ -103,51 +118,26 @@ public class PollingAutomationPerTableRunner implements Runnable
    /*******************************************************************************
     **
     *******************************************************************************/
-   public record TableActions(String tableName, AutomationStatus status, List<TableAutomationAction> actions)
+   public record TableActions(String tableName, AutomationStatus status)
    {
    }
 
 
 
    /*******************************************************************************
-    **
+    ** basically just get a list of tables which at least *could* have automations
+    ** run - either meta-data automations, or table-triggers (data/user defined).
     *******************************************************************************/
    public static List<TableActions> getTableActions(QInstance instance, String providerName)
    {
-      Map<String, Map<AutomationStatus, List<TableAutomationAction>>> workingTableActionMap = new HashMap<>();
-      List<TableActions>                                              tableActionList       = new ArrayList<>();
+      List<TableActions> tableActionList = new ArrayList<>();
 
-      //////////////////////////////////////////////////////////////////////
-      // todo - share logic like this among any automation implementation //
-      //////////////////////////////////////////////////////////////////////
       for(QTableMetaData table : instance.getTables().values())
       {
          if(table.getAutomationDetails() != null && providerName.equals(table.getAutomationDetails().getProviderName()))
          {
-            ///////////////////////////////////////////////////////////////////////////
-            // organize the table's actions by type                                  //
-            // todo - in future, need user-defined actions here too (and refreshed!) //
-            ///////////////////////////////////////////////////////////////////////////
-            for(TableAutomationAction action : table.getAutomationDetails().getActions())
-            {
-               AutomationStatus automationStatus = triggerEventAutomationStatusMap.get(action.getTriggerEvent());
-               workingTableActionMap.putIfAbsent(table.getName(), new HashMap<>());
-               workingTableActionMap.get(table.getName()).putIfAbsent(automationStatus, new ArrayList<>());
-               workingTableActionMap.get(table.getName()).get(automationStatus).add(action);
-            }
-
-            ////////////////////////////////////////////
-            // convert the map to tableAction records //
-            ////////////////////////////////////////////
-            for(Map.Entry<AutomationStatus, List<TableAutomationAction>> entry : workingTableActionMap.get(table.getName()).entrySet())
-            {
-               AutomationStatus            automationStatus = entry.getKey();
-               List<TableAutomationAction> actionList       = entry.getValue();
-
-               actionList.sort(Comparator.comparing(TableAutomationAction::getPriority));
-
-               tableActionList.add(new TableActions(table.getName(), automationStatus, actionList));
-            }
+            tableActionList.add(new TableActions(table.getName(), AutomationStatus.PENDING_INSERT_AUTOMATIONS));
+            tableActionList.add(new TableActions(table.getName(), AutomationStatus.PENDING_UPDATE_AUTOMATIONS));
          }
       }
 
@@ -175,14 +165,16 @@ public class PollingAutomationPerTableRunner implements Runnable
    @Override
    public void run()
    {
+      QContext.init(instance, sessionSupplier.get());
+
       String originalThreadName = Thread.currentThread().getName();
-      Thread.currentThread().setName(name + StandardScheduledExecutor.newThreadNameRandomSuffix());
+      Thread.currentThread().setName(name);
       LOG.debug("Running " + this.getClass().getSimpleName() + "[" + name + "]");
 
       try
       {
          QSession session = sessionSupplier != null ? sessionSupplier.get() : new QSession();
-         processTableInsertOrUpdate(instance.getTable(tableActions.tableName()), session, tableActions.status(), tableActions.actions());
+         processTableInsertOrUpdate(instance.getTable(tableActions.tableName()), session, tableActions.status());
       }
       catch(Exception e)
       {
@@ -191,6 +183,7 @@ public class PollingAutomationPerTableRunner implements Runnable
       finally
       {
          Thread.currentThread().setName(originalThreadName);
+         QContext.clear();
       }
    }
 
@@ -199,8 +192,12 @@ public class PollingAutomationPerTableRunner implements Runnable
    /*******************************************************************************
     ** Query for and process records that have a PENDING_INSERT or PENDING_UPDATE status on a given table.
     *******************************************************************************/
-   private void processTableInsertOrUpdate(QTableMetaData table, QSession session, AutomationStatus automationStatus, List<TableAutomationAction> actions) throws QException
+   public void processTableInsertOrUpdate(QTableMetaData table, QSession session, AutomationStatus automationStatus) throws QException
    {
+      /////////////////////////////////////////////////////////////////////////
+      // get the actions to run against this table in this automation status //
+      /////////////////////////////////////////////////////////////////////////
+      List<TableAutomationAction> actions = getTableActions(table, automationStatus);
       if(CollectionUtils.nullSafeIsEmpty(actions))
       {
          return;
@@ -219,8 +216,7 @@ public class PollingAutomationPerTableRunner implements Runnable
 
       asyncRecordPipeLoop.run("PollingAutomationRunner>Query>" + automationStatus + ">" + table.getName(), null, recordPipe, (status) ->
          {
-            QueryInput queryInput = new QueryInput(instance);
-            queryInput.setSession(session);
+            QueryInput queryInput = new QueryInput();
             queryInput.setTableName(table.getName());
 
             AutomationStatusTrackingType statusTrackingType = automationDetails.getStatusTracking().getType();
@@ -246,6 +242,83 @@ public class PollingAutomationPerTableRunner implements Runnable
 
 
 
+   /*******************************************************************************
+    ** get the actions to run against a table in an automation status.  both from
+    ** metaData and tableTriggers/data.
+    *******************************************************************************/
+   private List<TableAutomationAction> getTableActions(QTableMetaData table, AutomationStatus automationStatus) throws QException
+   {
+      List<TableAutomationAction> rs           = new ArrayList<>();
+      TriggerEvent                triggerEvent = automationStatusTriggerEventMap.get(automationStatus);
+
+      ///////////////////////////////////////////////////////////
+      // start with any actions defined in the table meta data //
+      ///////////////////////////////////////////////////////////
+      for(TableAutomationAction action : table.getAutomationDetails().getActions())
+      {
+         if(action.getTriggerEvent().equals(triggerEvent))
+         {
+            rs.add(action);
+         }
+      }
+
+      /////////////////////////////////////////////////
+      // next add any tableTriggers, defined in data //
+      /////////////////////////////////////////////////
+      if(QContext.getQInstance().getTable(TableTrigger.TABLE_NAME) != null)
+      {
+         QueryInput queryInput = new QueryInput();
+         queryInput.setTableName(TableTrigger.TABLE_NAME);
+         queryInput.setFilter(new QQueryFilter(
+            new QFilterCriteria("tableName", QCriteriaOperator.EQUALS, table.getName()),
+            new QFilterCriteria(triggerEvent.equals(TriggerEvent.POST_INSERT) ? "postInsert" : "postUpdate", QCriteriaOperator.EQUALS, true)
+         ));
+         QueryOutput queryOutput = new QueryAction().execute(queryInput);
+         for(QRecord record : queryOutput.getRecords())
+         {
+            TableTrigger tableTrigger = new TableTrigger(record);
+
+            try
+            {
+               QQueryFilter filter   = null;
+               Integer      filterId = tableTrigger.getFilterId();
+               if(filterId != null)
+               {
+                  GetInput getInput = new GetInput();
+                  getInput.setTableName(SavedFilter.TABLE_NAME);
+                  getInput.setPrimaryKey(filterId);
+                  GetOutput getOutput = new GetAction().execute(getInput);
+                  if(getOutput.getRecord() != null)
+                  {
+                     SavedFilter savedFilter = new SavedFilter(getOutput.getRecord());
+                     filter = JsonUtils.toObject(savedFilter.getFilterJson(), QQueryFilter.class);
+                  }
+               }
+
+               rs.add(new TableAutomationAction()
+                  .withName("Script:" + tableTrigger.getScriptId())
+                  .withFilter(filter)
+                  .withTriggerEvent(triggerEvent)
+                  .withPriority(tableTrigger.getPriority())
+                  .withCodeReference(new QCodeReference(RunRecordScriptAutomationHandler.class))
+                  .withValues(MapBuilder.of("scriptId", tableTrigger.getScriptId()))
+                  .withIncludeRecordAssociations(true)
+               );
+            }
+            catch(Exception e)
+            {
+               LOG.error("Error setting up table trigger", e, logPair("tableTriggerId", tableTrigger.getId()));
+            }
+         }
+      }
+
+      rs.sort(Comparator.comparing(taa -> Objects.requireNonNullElse(taa.getPriority(), Integer.MAX_VALUE)));
+
+      return (rs);
+   }
+
+
+
    /*******************************************************************************
     ** For a set of records that were found to be in a PENDING state - run all the
     ** table's actions against them - IF they are found to match the action's filter
@@ -269,22 +342,9 @@ public class PollingAutomationPerTableRunner implements Runnable
       boolean anyActionsFailed = false;
       for(TableAutomationAction action : actions)
       {
-         try
+         boolean hadError = applyActionToRecords(table, records, action);
+         if(hadError)
          {
-            //////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            // note - this method - will re-query the objects, so we should have confidence that their data is fresh... //
-            //////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            List<QRecord> matchingQRecords = getRecordsMatchingActionFilter(session, table, records, action);
-            LOG.debug("Of the {} records that were pending automations, {} of them match the filter on the action {}", records.size(), matchingQRecords.size(), action);
-            if(CollectionUtils.nullSafeHasContents(matchingQRecords))
-            {
-               LOG.debug("  Processing " + matchingQRecords.size() + " records in " + table + " for action " + action);
-               applyActionToMatchingRecords(instance, session, table, matchingQRecords, action);
-            }
-         }
-         catch(Exception e)
-         {
-            LOG.warn("Caught exception processing records on " + table + " for action " + action, e);
             anyActionsFailed = true;
          }
       }
@@ -304,6 +364,37 @@ public class PollingAutomationPerTableRunner implements Runnable
 
 
 
+   /*******************************************************************************
+    ** Run one action over a list of records (if they match the action's filter).
+    **
+    ** @return hadError - true if an exception was caught; false if all OK.
+    *******************************************************************************/
+   protected boolean applyActionToRecords(QTableMetaData table, List<QRecord> records, TableAutomationAction action)
+   {
+      try
+      {
+         //////////////////////////////////////////////////////////////////////////////////////////////////////////////
+         // note - this method - will re-query the objects, so we should have confidence that their data is fresh... //
+         //////////////////////////////////////////////////////////////////////////////////////////////////////////////
+         List<QRecord> matchingQRecords = getRecordsMatchingActionFilter(table, records, action);
+         LOG.debug("Of the {} records that were pending automations, {} of them match the filter on the action {}", records.size(), matchingQRecords.size(), action);
+         if(CollectionUtils.nullSafeHasContents(matchingQRecords))
+         {
+            LOG.debug("  Processing " + matchingQRecords.size() + " records in " + table + " for action " + action);
+            applyActionToMatchingRecords(table, matchingQRecords, action);
+         }
+
+         return (false);
+      }
+      catch(Exception e)
+      {
+         LOG.warn("Caught exception processing records on " + table + " for action " + action, e);
+         return (true);
+      }
+   }
+
+
+
    /*******************************************************************************
     ** For a given action, and a list of records - return a new list, of the ones
     ** which match the action's filter (if there is one - if not, then all match).
@@ -316,32 +407,34 @@ public class PollingAutomationPerTableRunner implements Runnable
     ** but that will almost certainly give potentially different results than a true
     ** backend - e.g., just consider if the DB is case-sensitive for strings...
     *******************************************************************************/
-   private List<QRecord> getRecordsMatchingActionFilter(QSession session, QTableMetaData table, List<QRecord> records, TableAutomationAction action) throws QException
+   private List<QRecord> getRecordsMatchingActionFilter(QTableMetaData table, List<QRecord> records, TableAutomationAction action) throws QException
    {
-      QueryInput queryInput = new QueryInput(instance);
-      queryInput.setSession(session);
+      QueryInput queryInput = new QueryInput();
       queryInput.setTableName(table.getName());
 
+      ///////////////////////////////////////////////////////////////////////////////////////
+      // set up a filter that is for the primary keys IN the list that we identified above //
+      ///////////////////////////////////////////////////////////////////////////////////////
       QQueryFilter filter = new QQueryFilter();
+      filter.addCriteria(new QFilterCriteria(table.getPrimaryKeyField(), QCriteriaOperator.IN, records.stream().map(r -> r.getValue(table.getPrimaryKeyField())).toList()));
 
-      /////////////////////////////////////////////////////////////////////////////////////////////////////
-      // copy filter criteria from the action's filter to a new filter that we'll run here.              //
-      // Critically - don't modify the filter object on the action!  as that object has a long lifespan. //
-      /////////////////////////////////////////////////////////////////////////////////////////////////////
       if(action.getFilter() != null)
       {
-         if(action.getFilter().getCriteria() != null)
-         {
-            action.getFilter().getCriteria().forEach(filter::addCriteria);
-         }
+         /////////////////////////////////////////////////////////////////////////////////////////////////////
+         // if the action defines a filter of its own, add that to the filter we'll run now as a sub-filter //
+         // not entirely clear if this needs to be a clone, but, it feels safe and cheap enough             //
+         /////////////////////////////////////////////////////////////////////////////////////////////////////
+         filter.addSubFilter(action.getFilter().clone());
+
+         ////////////////////////////////////////////////////////////////////////////////////////////////////////////
+         // we also want to set order-bys from the action into our filter (since they only apply at the top-level) //
+         ////////////////////////////////////////////////////////////////////////////////////////////////////////////
          if(action.getFilter().getOrderBys() != null)
          {
             action.getFilter().getOrderBys().forEach(filter::addOrderBy);
          }
       }
 
-      filter.addCriteria(new QFilterCriteria(table.getPrimaryKeyField(), QCriteriaOperator.IN, records.stream().map(r -> r.getValue(table.getPrimaryKeyField())).toList()));
-
       /////////////////////////////////////////////////////////////////////////////////////////////
       // always add order-by the primary key, to give more predictable/consistent results        //
       // todo - in future - if this becomes a source of slowness, make this a config to opt-out? //
@@ -350,6 +443,8 @@ public class PollingAutomationPerTableRunner implements Runnable
 
       queryInput.setFilter(filter);
 
+      queryInput.setIncludeAssociations(action.getIncludeRecordAssociations());
+
       return (new QueryAction().execute(queryInput).getRecords());
    }
 
@@ -359,7 +454,7 @@ public class PollingAutomationPerTableRunner implements Runnable
     ** Finally, actually run action code against a list of known matching records.
     ** todo not commit - move to somewhere genericer
     *******************************************************************************/
-   public static void applyActionToMatchingRecords(QInstance instance, QSession session, QTableMetaData table, List<QRecord> records, TableAutomationAction action) throws Exception
+   public static void applyActionToMatchingRecords(QTableMetaData table, List<QRecord> records, TableAutomationAction action) throws Exception
    {
       if(StringUtils.hasContent(action.getProcessName()))
       {
@@ -368,8 +463,7 @@ public class PollingAutomationPerTableRunner implements Runnable
          // tell it to SKIP frontend steps.                                                     //
          // give the process a callback w/ a query filter that has the p-keys of these records. //
          /////////////////////////////////////////////////////////////////////////////////////////
-         RunProcessInput runProcessInput = new RunProcessInput(instance);
-         runProcessInput.setSession(session);
+         RunProcessInput runProcessInput = new RunProcessInput();
          runProcessInput.setProcessName(action.getProcessName());
          runProcessInput.setFrontendStepBehavior(RunProcessInput.FrontendStepBehavior.SKIP);
          runProcessInput.setCallback(new QProcessCallback()
@@ -382,20 +476,29 @@ public class PollingAutomationPerTableRunner implements Runnable
             }
          });
 
-         RunProcessAction runProcessAction = new RunProcessAction();
-         RunProcessOutput runProcessOutput = runProcessAction.execute(runProcessInput);
-         if(runProcessOutput.getException().isPresent())
+         try
          {
-            throw (runProcessOutput.getException().get());
+            QContext.pushAction(runProcessInput);
+
+            RunProcessAction runProcessAction = new RunProcessAction();
+            RunProcessOutput runProcessOutput = runProcessAction.execute(runProcessInput);
+            if(runProcessOutput.getException().isPresent())
+            {
+               throw (runProcessOutput.getException().get());
+            }
+         }
+         finally
+         {
+            QContext.popAction();
          }
       }
       else if(action.getCodeReference() != null)
       {
          LOG.debug("    Executing action: [" + action.getName() + "] as code reference: " + action.getCodeReference());
-         RecordAutomationInput input = new RecordAutomationInput(instance);
-         input.setSession(session);
+         RecordAutomationInput input = new RecordAutomationInput();
          input.setTableName(table.getName());
          input.setRecordList(records);
+         input.setAction(action);
 
          RecordAutomationHandler recordAutomationHandler = QCodeLoader.getRecordAutomationHandler(action);
          recordAutomationHandler.execute(input);

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/customizers/AbstractPostDeleteCustomizer.java

@@ -0,0 +1,82 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2022.  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.customizers;
+
+
+import java.util.List;
+import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.model.actions.tables.delete.DeleteInput;
+import com.kingsrook.qqq.backend.core.model.data.QRecord;
+
+
+/*******************************************************************************
+ ** Abstract class that a table can specify an implementation of, to provide
+ ** custom actions after a delete takes place.
+ **
+ ** General implementation would be, to iterate over the records (ones which didn't
+ ** have a delete error), and look at their values:
+ ** - possibly adding Errors (`addError`) or Warnings (`addWarning`) to the records?
+ ** - possibly throwing an exception - though doing so won't stop the delete, and instead
+ **   will just set a warning on all of the deleted records...
+ ** - doing "whatever else" you may want to do.
+ ** - returning the list of records (can be the input list) that you want to go back
+ **   to the caller - this is how errors and warnings are propagated .
+ **
+ ** Note that the full deleteInput is available as a field in this class.
+ **
+ ** A future enhancement here may be to take (as fields in this class) the list of
+ ** records that the delete action marked in error - the user might want to do
+ ** something special with them (idk, try some other way to delete them?)
+ *******************************************************************************/
+public abstract class AbstractPostDeleteCustomizer
+{
+   protected DeleteInput deleteInput;
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public abstract List<QRecord> apply(List<QRecord> records) throws QException;
+
+
+
+   /*******************************************************************************
+    ** Getter for deleteInput
+    **
+    *******************************************************************************/
+   public DeleteInput getDeleteInput()
+   {
+      return deleteInput;
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for deleteInput
+    **
+    *******************************************************************************/
+   public void setDeleteInput(DeleteInput deleteInput)
+   {
+      this.deleteInput = deleteInput;
+   }
+}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/customizers/AbstractPostInsertCustomizer.java

@@ -23,12 +23,24 @@ package com.kingsrook.qqq.backend.core.actions.customizers;
 
 
 import java.util.List;
+import com.kingsrook.qqq.backend.core.exceptions.QException;
 import com.kingsrook.qqq.backend.core.model.actions.tables.insert.InsertInput;
 import com.kingsrook.qqq.backend.core.model.data.QRecord;
 
 
 /*******************************************************************************
+ ** Abstract class that a table can specify an implementation of, to provide
+ ** custom actions after an insert takes place.
  **
+ ** General implementation would be, to iterate over the records (the outputs of
+ ** the insert action), and look at their values:
+ ** - possibly adding Errors (`addError`) or Warnings (`addWarning`) to the records
+ ** - possibly throwing an exception - though doing so won't stop the update, and instead
+ **   will just set a warning on all of the updated records...
+ ** - doing "whatever else" you may want to do.
+ ** - returning the list of records (can be the input list) that you want to go back to the caller.
+ **
+ ** Note that the full insertInput is available as a field in this class.
  *******************************************************************************/
 public abstract class AbstractPostInsertCustomizer
 {
@@ -39,7 +51,7 @@ public abstract class AbstractPostInsertCustomizer
    /*******************************************************************************
     **
     *******************************************************************************/
-   public abstract List<QRecord> apply(List<QRecord> records);
+   public abstract List<QRecord> apply(List<QRecord> records) throws QException;
 
 
 

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/customizers/AbstractPostUpdateCustomizer.java

@@ -0,0 +1,130 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2022.  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.customizers;
+
+
+import java.io.Serializable;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.model.actions.tables.update.UpdateInput;
+import com.kingsrook.qqq.backend.core.model.data.QRecord;
+
+
+/*******************************************************************************
+ ** Abstract class that a table can specify an implementation of, to provide
+ ** custom actions after an update takes place.
+ **
+ ** General implementation would be, to iterate over the records (the outputs of
+ ** the update action), and look at their values:
+ ** - possibly adding Errors (`addError`) or Warnings (`addWarning`) to the records?
+ ** - possibly throwing an exception - though doing so won't stop the update, and instead
+ **   will just set a warning on all of the updated records...
+ ** - doing "whatever else" you may want to do.
+ ** - returning the list of records (can be the input list) that you want to go back to the caller.
+ **
+ ** Note that the full updateInput is available as a field in this class, and the
+ ** "old records" (e.g., with values freshly fetched from the backend) will be
+ ** available (if the backend supports it) - both as a list (`getOldRecordList`)
+ ** and as a memoized (by this class) map of primaryKey to record (`getOldRecordMap`).
+ *******************************************************************************/
+public abstract class AbstractPostUpdateCustomizer
+{
+   protected UpdateInput   updateInput;
+   protected List<QRecord> oldRecordList;
+
+   private Map<Serializable, QRecord> oldRecordMap = null;
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public abstract List<QRecord> apply(List<QRecord> records) throws QException;
+
+
+
+   /*******************************************************************************
+    ** Getter for updateInput
+    **
+    *******************************************************************************/
+   public UpdateInput getUpdateInput()
+   {
+      return updateInput;
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for updateInput
+    **
+    *******************************************************************************/
+   public void setUpdateInput(UpdateInput updateInput)
+   {
+      this.updateInput = updateInput;
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public void setOldRecordList(List<QRecord> oldRecordList)
+   {
+      this.oldRecordList = oldRecordList;
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public List<QRecord> getOldRecordList()
+   {
+      return oldRecordList;
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   protected Map<Serializable, QRecord> getOldRecordMap()
+   {
+      if(oldRecordMap == null)
+      {
+         oldRecordMap = new HashMap<>();
+
+         if(oldRecordList != null && updateInput != null)
+         {
+            for(QRecord qRecord : oldRecordList)
+            {
+               oldRecordMap.put(qRecord.getValue(updateInput.getTable().getPrimaryKeyField()), qRecord);
+            }
+         }
+      }
+
+      return (oldRecordMap);
+   }
+
+}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/customizers/AbstractPreDeleteCustomizer.java

@@ -0,0 +1,119 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2022.  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.customizers;
+
+
+import java.util.List;
+import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.model.actions.tables.delete.DeleteInput;
+import com.kingsrook.qqq.backend.core.model.data.QRecord;
+
+
+/*******************************************************************************
+ ** Abstract class that a table can specify an implementation of, to provide
+ ** custom actions before a delete takes place.
+ **
+ ** It's important for implementations to be aware of the isPreview field, which
+ ** is set to true when the code is running to give users advice, e.g., on a review
+ ** screen - vs. being false when the action is ACTUALLY happening.  So, if you're doing
+ ** things like storing data, you don't want to do that if isPreview is true!!
+ **
+ ** General implementation would be, to iterate over the records (which the DeleteAction
+ ** would look up based on the inputs to the delete action), and look at their values:
+ ** - possibly adding Errors (`addError`) or Warnings (`addWarning`) to the records
+ ** - possibly throwing an exception - if you really don't want the delete operation to continue.
+ ** - doing "whatever else" you may want to do.
+ ** - returning the list of records (can be the input list) - this is how errors
+ **   and warnings are propagated to the DeleteAction.  Note that any records with
+ **   an error will NOT proceed to the backend's delete interface - but those with
+ **   warnings will.
+ **
+ ** Note that the full deleteInput is available as a field in this class.
+ **
+ *******************************************************************************/
+public abstract class AbstractPreDeleteCustomizer
+{
+   protected DeleteInput deleteInput;
+
+   protected boolean isPreview = false;
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public abstract List<QRecord> apply(List<QRecord> records) throws QException;
+
+
+
+   /*******************************************************************************
+    ** Getter for deleteInput
+    **
+    *******************************************************************************/
+   public DeleteInput getDeleteInput()
+   {
+      return deleteInput;
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for deleteInput
+    **
+    *******************************************************************************/
+   public void setDeleteInput(DeleteInput deleteInput)
+   {
+      this.deleteInput = deleteInput;
+   }
+
+
+
+   /*******************************************************************************
+    ** Getter for isPreview
+    *******************************************************************************/
+   public boolean getIsPreview()
+   {
+      return (this.isPreview);
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for isPreview
+    *******************************************************************************/
+   public void setIsPreview(boolean isPreview)
+   {
+      this.isPreview = isPreview;
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for isPreview
+    *******************************************************************************/
+   public AbstractPreDeleteCustomizer withIsPreview(boolean isPreview)
+   {
+      this.isPreview = isPreview;
+      return (this);
+   }
+
+}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/customizers/AbstractPreInsertCustomizer.java

@@ -0,0 +1,116 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2022.  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.customizers;
+
+
+import java.util.List;
+import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.model.actions.tables.insert.InsertInput;
+import com.kingsrook.qqq.backend.core.model.data.QRecord;
+
+
+/*******************************************************************************
+ ** Abstract class that a table can specify an implementation of, to provide
+ ** custom actions before an insert takes place.
+ **
+ ** It's important for implementations to be aware of the isPreview field, which
+ ** is set to true when the code is running to give users advice, e.g., on a review
+ ** screen - vs. being false when the action is ACTUALLY happening.  So, if you're doing
+ ** things like storing data, you don't want to do that if isPreview is true!!
+ **
+ ** General implementation would be, to iterate over the records (the inputs to
+ ** the insert action), and look at their values:
+ ** - possibly adding Errors (`addError`) or Warnings (`addWarning`) to the records
+ ** - possibly manipulating values (`setValue`)
+ ** - possibly throwing an exception - if you really don't want the insert operation to continue.
+ ** - doing "whatever else" you may want to do.
+ ** - returning the list of records (can be the input list) that you want to go on to the backend implementation class.
+ **
+ ** Note that the full insertInput is available as a field in this class.
+ *******************************************************************************/
+public abstract class AbstractPreInsertCustomizer
+{
+   protected InsertInput insertInput;
+
+   protected boolean isPreview = false;
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public abstract List<QRecord> apply(List<QRecord> records) throws QException;
+
+
+
+   /*******************************************************************************
+    ** Getter for insertInput
+    **
+    *******************************************************************************/
+   public InsertInput getInsertInput()
+   {
+      return insertInput;
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for insertInput
+    **
+    *******************************************************************************/
+   public void setInsertInput(InsertInput insertInput)
+   {
+      this.insertInput = insertInput;
+   }
+
+
+
+   /*******************************************************************************
+    ** Getter for isPreview
+    *******************************************************************************/
+   public boolean getIsPreview()
+   {
+      return (this.isPreview);
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for isPreview
+    *******************************************************************************/
+   public void setIsPreview(boolean isPreview)
+   {
+      this.isPreview = isPreview;
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for isPreview
+    *******************************************************************************/
+   public AbstractPreInsertCustomizer withIsPreview(boolean isPreview)
+   {
+      this.isPreview = isPreview;
+      return (this);
+   }
+
+}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/customizers/AbstractPreUpdateCustomizer.java

@@ -0,0 +1,163 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2022.  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.customizers;
+
+
+import java.io.Serializable;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.model.actions.tables.update.UpdateInput;
+import com.kingsrook.qqq.backend.core.model.data.QRecord;
+
+
+/*******************************************************************************
+ ** Abstract class that a table can specify an implementation of, to provide
+ ** custom actions before an update takes place.
+ **
+ ** It's important for implementations to be aware of the isPreview field, which
+ ** is set to true when the code is running to give users advice, e.g., on a review
+ ** screen - vs. being false when the action is ACTUALLY happening.  So, if you're doing
+ ** things like storing data, you don't want to do that if isPreview is true!!
+ **
+ ** General implementation would be, to iterate over the records (the inputs to
+ ** the update action), and look at their values:
+ ** - possibly adding Errors (`addError`) or Warnings (`addWarning`) to the records
+ ** - possibly manipulating values (`setValue`)
+ ** - possibly throwing an exception - if you really don't want the update operation to continue.
+ ** - doing "whatever else" you may want to do.
+ ** - returning the list of records (can be the input list) that you want to go on to the backend implementation class.
+ **
+ ** Note that the full updateInput is available as a field in this class, and the
+ ** "old records" (e.g., with values freshly fetched from the backend) will be
+ ** available (if the backend supports it) - both as a list (`getOldRecordList`)
+ ** and as a memoized (by this class) map of primaryKey to record (`getOldRecordMap`).
+ *******************************************************************************/
+public abstract class AbstractPreUpdateCustomizer
+{
+   protected UpdateInput   updateInput;
+   protected List<QRecord> oldRecordList;
+   protected boolean       isPreview = false;
+
+   private Map<Serializable, QRecord> oldRecordMap = null;
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public abstract List<QRecord> apply(List<QRecord> records) throws QException;
+
+
+
+   /*******************************************************************************
+    ** Getter for updateInput
+    **
+    *******************************************************************************/
+   public UpdateInput getUpdateInput()
+   {
+      return updateInput;
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for updateInput
+    **
+    *******************************************************************************/
+   public void setUpdateInput(UpdateInput updateInput)
+   {
+      this.updateInput = updateInput;
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public void setOldRecordList(List<QRecord> oldRecordList)
+   {
+      this.oldRecordList = oldRecordList;
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public List<QRecord> getOldRecordList()
+   {
+      return oldRecordList;
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   protected Map<Serializable, QRecord> getOldRecordMap()
+   {
+      if(oldRecordMap == null)
+      {
+         oldRecordMap = new HashMap<>();
+         for(QRecord qRecord : oldRecordList)
+         {
+            oldRecordMap.put(qRecord.getValue(updateInput.getTable().getPrimaryKeyField()), qRecord);
+         }
+      }
+
+      return (oldRecordMap);
+   }
+
+
+
+   /*******************************************************************************
+    ** Getter for isPreview
+    *******************************************************************************/
+   public boolean getIsPreview()
+   {
+      return (this.isPreview);
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for isPreview
+    *******************************************************************************/
+   public void setIsPreview(boolean isPreview)
+   {
+      this.isPreview = isPreview;
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for isPreview
+    *******************************************************************************/
+   public AbstractPreUpdateCustomizer withIsPreview(boolean isPreview)
+   {
+      this.isPreview = isPreview;
+      return (this);
+   }
+
+}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/customizers/ChildInserterPostInsertCustomizer.java

@@ -29,28 +29,30 @@ import java.util.List;
 import com.kingsrook.qqq.backend.core.actions.tables.InsertAction;
 import com.kingsrook.qqq.backend.core.actions.tables.UpdateAction;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.exceptions.QRuntimeException;
 import com.kingsrook.qqq.backend.core.model.actions.tables.insert.InsertInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.insert.InsertOutput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.update.UpdateInput;
 import com.kingsrook.qqq.backend.core.model.data.QRecord;
 import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
+import com.kingsrook.qqq.backend.core.model.statusmessages.QStatusMessage;
+import com.kingsrook.qqq.backend.core.model.statusmessages.QWarningMessage;
+import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
 
 
 /*******************************************************************************
  ** Standard/re-usable post-insert customizer, for the use case where, when we
  ** do an insert into table "parent", we want a record automatically inserted into
- ** table "child", and there's a foreign key in "parent", pointed at "child"
- ** e.g., named: "parent.childId".
+ ** table "child".  Optionally (based on RelationshipType), there can be a foreign
+ ** key in "parent", pointed at "child".  e.g., named: "parent.childId".
  **
- ** A similar use-case would have the foreign key in the child table - in which case,
- ** we could add a "Type" enum, plus abstract method to get our "Type", then logic
- ** to switch behavior based on type.  See existing type enum, but w/ only 1 case :)
  *******************************************************************************/
 public abstract class ChildInserterPostInsertCustomizer extends AbstractPostInsertCustomizer
 {
    public enum RelationshipType
    {
-      PARENT_POINTS_AT_CHILD
+      PARENT_POINTS_AT_CHILD,
+      CHILD_POINTS_AT_PARENT
    }
 
 
@@ -65,10 +67,17 @@ public abstract class ChildInserterPostInsertCustomizer extends AbstractPostInse
     *******************************************************************************/
    public abstract String getChildTableName();
 
+
+
    /*******************************************************************************
     **
     *******************************************************************************/
-   public abstract String getForeignKeyFieldName();
+   public String getForeignKeyFieldName()
+   {
+      return (null);
+   }
+
+
 
    /*******************************************************************************
     **
@@ -85,7 +94,7 @@ public abstract class ChildInserterPostInsertCustomizer extends AbstractPostInse
    {
       try
       {
-         List<QRecord>  rs               = new ArrayList<>();
+         List<QRecord>  rs               = records;
          List<QRecord>  childrenToInsert = new ArrayList<>();
          QTableMetaData table            = getInsertInput().getTable();
          QTableMetaData childTable       = getInsertInput().getInstance().getTable(getChildTableName());
@@ -94,12 +103,37 @@ public abstract class ChildInserterPostInsertCustomizer extends AbstractPostInse
          // iterate over the inserted records, building a list child records to insert //
          // for ones missing a value in the foreign key field.                         //
          ////////////////////////////////////////////////////////////////////////////////
-         for(QRecord record : records)
+         switch(getRelationshipType())
          {
-            if(record.getValue(getForeignKeyFieldName()) == null)
+            case PARENT_POINTS_AT_CHILD ->
             {
-               childrenToInsert.add(buildChildForRecord(record));
+               String foreignKeyFieldName = getForeignKeyFieldName();
+               try
+               {
+                  table.getField(foreignKeyFieldName);
+               }
+               catch(Exception e)
+               {
+                  throw new QRuntimeException("For RelationshipType.PARENT_POINTS_AT_CHILD, a valid foreignKeyFieldName in the parent table must be given.  "
+                     + "[" + foreignKeyFieldName + "] is not a valid field name in table [" + table.getName() + "]");
+               }
+
+               for(QRecord record : records)
+               {
+                  if(record.getValue(foreignKeyFieldName) == null)
+                  {
+                     childrenToInsert.add(buildChildForRecord(record));
+                  }
+               }
             }
+            case CHILD_POINTS_AT_PARENT ->
+            {
+               for(QRecord record : records)
+               {
+                  childrenToInsert.add(buildChildForRecord(record));
+               }
+            }
+            default -> throw new IllegalStateException("Unexpected value: " + getRelationshipType());
          }
 
          ///////////////////////////////////////////////////////////////////////////////////
@@ -113,47 +147,83 @@ public abstract class ChildInserterPostInsertCustomizer extends AbstractPostInse
          /////////////////////////
          // insert the children //
          /////////////////////////
-         InsertInput insertInput = new InsertInput(getInsertInput().getInstance());
-         insertInput.setSession(getInsertInput().getSession());
+         InsertInput insertInput = new InsertInput();
          insertInput.setTableName(getChildTableName());
          insertInput.setRecords(childrenToInsert);
          insertInput.setTransaction(this.insertInput.getTransaction());
          InsertOutput      insertOutput           = new InsertAction().execute(insertInput);
          Iterator<QRecord> insertedRecordIterator = insertOutput.getRecords().iterator();
 
+         /////////////////////////////////////////////////////////////////////////////////
+         // check for any errors when inserting the children, if any errors were found, //
+         // then set a warning in the parent with the details of the problem            //
+         /////////////////////////////////////////////////////////////////////////////////
+
          //////////////////////////////////////////////////////////////////////////////////////////////////////
+         // for the PARENT_POINTS_AT_CHILD relationship type:
          // iterate over the original list of records again - for any that need a child (e.g., are missing   //
          // foreign key), set their foreign key to a newly inserted child's key, and add them to be updated. //
          //////////////////////////////////////////////////////////////////////////////////////////////////////
-         List<QRecord> recordsToUpdate = new ArrayList<>();
-         for(QRecord record : records)
+         switch(getRelationshipType())
          {
-            Serializable primaryKey = record.getValue(table.getPrimaryKeyField());
-            if(record.getValue(getForeignKeyFieldName()) == null)
+            case PARENT_POINTS_AT_CHILD ->
             {
-               Serializable foreignKey = insertedRecordIterator.next().getValue(childTable.getPrimaryKeyField());
-               recordsToUpdate.add(new QRecord().withValue(table.getPrimaryKeyField(), primaryKey).withValue(getForeignKeyFieldName(), foreignKey));
-               record.setValue(getForeignKeyFieldName(), foreignKey);
-               rs.add(record);
+               rs = new ArrayList<>();
+               List<QRecord> recordsToUpdate = new ArrayList<>();
+               for(QRecord record : records)
+               {
+                  Serializable primaryKey = record.getValue(table.getPrimaryKeyField());
+                  if(record.getValue(getForeignKeyFieldName()) == null)
+                  {
+                     ///////////////////////////////////////////////////////////////////////////////////////////////////
+                     // get the corresponding child record, if it has any errors, set that as a warning in the parent //
+                     ///////////////////////////////////////////////////////////////////////////////////////////////////
+                     QRecord childRecord = insertedRecordIterator.next();
+                     if(CollectionUtils.nullSafeHasContents(childRecord.getErrors()))
+                     {
+                        for(QStatusMessage error : childRecord.getErrors())
+                        {
+                           record.addWarning(new QWarningMessage("Error creating child " + childTable.getLabel() + " (" + error.toString() + ")"));
+                        }
+                        rs.add(record);
+                        continue;
+                     }
+
+                     Serializable foreignKey = childRecord.getValue(childTable.getPrimaryKeyField());
+                     recordsToUpdate.add(new QRecord().withValue(table.getPrimaryKeyField(), primaryKey).withValue(getForeignKeyFieldName(), foreignKey));
+                     record.setValue(getForeignKeyFieldName(), foreignKey);
+                     rs.add(record);
+                  }
+                  else
+                  {
+                     rs.add(record);
+                  }
+               }
+
+               ////////////////////////////////////////////////////////////////////////////
+               // update the originally inserted records to reference their new children //
+               ////////////////////////////////////////////////////////////////////////////
+               UpdateInput updateInput = new UpdateInput();
+               updateInput.setTableName(getInsertInput().getTableName());
+               updateInput.setRecords(recordsToUpdate);
+               updateInput.setTransaction(this.insertInput.getTransaction());
+               new UpdateAction().execute(updateInput);
             }
-            else
+            case CHILD_POINTS_AT_PARENT ->
             {
-               rs.add(record);
+               ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+               // todo - some version of looking at the inserted children to confirm that they were inserted, and updating the parents with warnings if they weren't //
+               ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             }
+            default -> throw new IllegalStateException("Unexpected value: " + getRelationshipType());
          }
 
-         ////////////////////////////////////////////////////////////////////////////
-         // update the originally inserted records to reference their new children //
-         ////////////////////////////////////////////////////////////////////////////
-         UpdateInput updateInput = new UpdateInput(insertInput.getInstance());
-         updateInput.setSession(getInsertInput().getSession());
-         updateInput.setTableName(getInsertInput().getTableName());
-         updateInput.setRecords(recordsToUpdate);
-         updateInput.setTransaction(this.insertInput.getTransaction());
-         new UpdateAction().execute(updateInput);
-
          return (rs);
       }
+      catch(RuntimeException re)
+      {
+         throw (re);
+      }
       catch(Exception e)
       {
          throw new RuntimeException("Error inserting new child records for new parent records", e);

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/customizers/QCodeLoader.java

@@ -28,13 +28,13 @@ import com.kingsrook.qqq.backend.core.actions.automation.RecordAutomationHandler
 import com.kingsrook.qqq.backend.core.actions.processes.BackendStep;
 import com.kingsrook.qqq.backend.core.actions.values.QCustomPossibleValueProvider;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
 import com.kingsrook.qqq.backend.core.model.metadata.code.QCodeReference;
 import com.kingsrook.qqq.backend.core.model.metadata.code.QCodeType;
 import com.kingsrook.qqq.backend.core.model.metadata.possiblevalues.QPossibleValueSource;
 import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.tables.automation.TableAutomationAction;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
+import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
 
 
 /*******************************************************************************
@@ -42,7 +42,7 @@ import org.apache.logging.log4j.Logger;
  *******************************************************************************/
 public class QCodeLoader
 {
-   private static final Logger LOG = LogManager.getLogger(QCodeLoader.class);
+   private static final QLogger LOG = QLogger.getLogger(QCodeLoader.class);
 
 
 
@@ -102,7 +102,7 @@ public class QCodeLoader
       }
       catch(Exception e)
       {
-         LOG.error("Error initializing customizer: " + codeReference);
+         LOG.error("Error initializing customizer", logPair("codeReference", codeReference), e);
 
          //////////////////////////////////////////////////////////////////////////////////////////////////////////
          // return null here - under the assumption that during normal run-time operations, we'll never hit here //
@@ -141,7 +141,7 @@ public class QCodeLoader
       }
       catch(Exception e)
       {
-         LOG.error("Error initializing customizer: " + codeReference);
+         LOG.error("Error initializing customizer", logPair("codeReference", codeReference), e);
 
          //////////////////////////////////////////////////////////////////////////////////////////////////////////
          // return null here - under the assumption that during normal run-time operations, we'll never hit here //
@@ -180,7 +180,7 @@ public class QCodeLoader
       }
       catch(Exception e)
       {
-         LOG.error("Error initializing customizer: " + codeReference);
+         LOG.error("Error initializing customizer", logPair("codeReference", codeReference), e);
 
          //////////////////////////////////////////////////////////////////////////////////////////////////////////
          // return null here - under the assumption that during normal run-time operations, we'll never hit here //

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/customizers/RecordCustomizerUtilityInterface.java

@@ -0,0 +1,149 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2023.  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.customizers;
+
+
+import java.io.Serializable;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+import com.kingsrook.qqq.backend.core.context.QContext;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
+import com.kingsrook.qqq.backend.core.model.data.QRecord;
+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.model.statusmessages.BadInputStatusMessage;
+import com.kingsrook.qqq.backend.core.utils.StringUtils;
+import com.kingsrook.qqq.backend.core.utils.ValueUtils;
+import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
+
+
+/*******************************************************************************
+ ** Interface with utility methods that pre insert/update/delete customizers
+ ** may want to use.
+ *******************************************************************************/
+public interface RecordCustomizerUtilityInterface
+{
+   QLogger LOG = QLogger.getLogger(RecordCustomizerUtilityInterface.class);
+
+
+
+   /*******************************************************************************
+    ** Container for an old value and a new value.
+    *******************************************************************************/
+   @SuppressWarnings("checkstyle:MethodName")
+   record Change(Serializable oldValue, Serializable newValue)
+   {
+   }
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   default Map<String, Change> getChanges(String tableName, QRecord oldRecord, QRecord newRecord)
+   {
+      Map<String, Change> rs = new HashMap<>();
+
+      QTableMetaData table = QContext.getQInstance().getTable(tableName);
+      for(Map.Entry<String, Serializable> entry : newRecord.getValues().entrySet())
+      {
+         String       fieldName = entry.getKey();
+         Serializable newValue  = entry.getValue();
+         Serializable oldValue  = oldRecord.getValue(fieldName);
+
+         try
+         {
+            QFieldMetaData field         = table.getField(fieldName);
+            Serializable   newTypedValue = ValueUtils.getValueAsFieldType(field.getType(), newValue);
+            Serializable   oldTypedValue = ValueUtils.getValueAsFieldType(field.getType(), oldValue);
+
+            if(!Objects.equals(oldTypedValue, newTypedValue))
+            {
+               rs.put(fieldName, new Change(oldTypedValue, newTypedValue));
+            }
+         }
+         catch(Exception e)
+         {
+            LOG.info("Error getting a value as field's type", e, logPair("fieldName", fieldName), logPair("oldValue", oldValue), logPair("newValue", newValue));
+         }
+      }
+
+      return (rs);
+   }
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   default void errorIfNoValue(Serializable value, QRecord record, String errorMessage)
+   {
+      errorIf(!StringUtils.hasContent(ValueUtils.getValueAsString(value)), record, errorMessage);
+   }
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   default void errorIfEditedValue(QRecord oldRecord, QRecord newRecord, String fieldName, String errorMessage)
+   {
+      if(newRecord.getValues().containsKey(fieldName))
+      {
+         errorIf(isChangedValue(oldRecord.getValue(fieldName), newRecord.getValue(fieldName)), newRecord, errorMessage);
+      }
+   }
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   default boolean isChangedValue(Serializable oldValue, Serializable newValue)
+   {
+      //////////////////////////////////////////////
+      // todo - probably ... some type "coercion" //
+      //////////////////////////////////////////////
+      return (!Objects.equals(oldValue, newValue));
+   }
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   default void errorIfAnyValue(Serializable value, QRecord record, String errorMessage)
+   {
+      if(StringUtils.hasContent(ValueUtils.getValueAsString(value)))
+      {
+         record.addError(new BadInputStatusMessage(errorMessage));
+      }
+   }
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   default void errorIf(boolean condition, QRecord record, String errorMessage)
+   {
+      if(condition)
+      {
+         record.addError(new BadInputStatusMessage(errorMessage));
+      }
+   }
+
+}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/customizers/TableCustomizers.java

@@ -26,33 +26,30 @@ package com.kingsrook.qqq.backend.core.actions.customizers;
  ** Enum definition of possible table customizers - "roles" for custom code that
  ** can be applied to tables.
  **
- ** Works with TableCustomizer (singular version of this name) objects, during
- ** instance validation, to provide validation of the referenced code (and to
- ** make such validation from sub-backend-modules possible in the future).
- **
- ** The idea of the 3rd argument here is to provide a way that we can enforce
- ** the type-parameters for the custom code.  E.g., if it's a Function - how
- ** can we check at run-time that the type-params are correct?  We couldn't find
- ** how to do this "reflectively", so we can instead try to run the custom code,
- ** passing it objects of the type that this customizer expects, and a validation
- ** error will raise upon ClassCastException...  This maybe could improve!
  *******************************************************************************/
 public enum TableCustomizers
 {
-   POST_QUERY_RECORD(new TableCustomizer("postQueryRecord", AbstractPostQueryCustomizer.class)),
-   POST_INSERT_RECORD(new TableCustomizer("postInsertRecord", AbstractPostInsertCustomizer.class));
+   POST_QUERY_RECORD("postQueryRecord", AbstractPostQueryCustomizer.class),
+   PRE_INSERT_RECORD("preInsertRecord", AbstractPreInsertCustomizer.class),
+   POST_INSERT_RECORD("postInsertRecord", AbstractPostInsertCustomizer.class),
+   PRE_UPDATE_RECORD("preUpdateRecord", AbstractPreUpdateCustomizer.class),
+   POST_UPDATE_RECORD("postUpdateRecord", AbstractPostUpdateCustomizer.class),
+   PRE_DELETE_RECORD("preDeleteRecord", AbstractPreDeleteCustomizer.class),
+   POST_DELETE_RECORD("postDeleteRecord", AbstractPostDeleteCustomizer.class);
 
 
-   private final TableCustomizer tableCustomizer;
+   private final String   role;
+   private final Class<?> expectedType;
 
 
 
    /*******************************************************************************
     **
     *******************************************************************************/
-   TableCustomizers(TableCustomizer tableCustomizer)
+   TableCustomizers(String role, Class<?> expectedType)
    {
-      this.tableCustomizer = tableCustomizer;
+      this.role = role;
+      this.expectedType = expectedType;
    }
 
 
@@ -65,7 +62,7 @@ public enum TableCustomizers
    {
       for(TableCustomizers value : values())
       {
-         if(value.tableCustomizer.getRole().equals(name))
+         if(value.role.equals(name))
          {
             return (value);
          }
@@ -76,24 +73,23 @@ public enum TableCustomizers
 
 
 
-   /*******************************************************************************
-    ** Getter for tableCustomizer
-    **
-    *******************************************************************************/
-   public TableCustomizer getTableCustomizer()
-   {
-      return tableCustomizer;
-   }
-
-
-
    /*******************************************************************************
     ** get the role from the tableCustomizer
     **
     *******************************************************************************/
    public String getRole()
    {
-      return (tableCustomizer.getRole());
+      return (role);
    }
 
+
+
+   /*******************************************************************************
+    ** Getter for expectedType
+    **
+    *******************************************************************************/
+   public Class<?> getExpectedType()
+   {
+      return expectedType;
+   }
 }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/dashboard/AbstractHTMLWidgetRenderer.java

@@ -26,12 +26,14 @@ import java.io.Serializable;
 import java.net.URLEncoder;
 import java.nio.charset.Charset;
 import java.nio.charset.StandardCharsets;
+import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
 import java.util.stream.Collectors;
 import com.kingsrook.qqq.backend.core.actions.dashboard.widgets.AbstractWidgetRenderer;
 import com.kingsrook.qqq.backend.core.actions.values.QValueFormatter;
+import com.kingsrook.qqq.backend.core.context.QContext;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
 import com.kingsrook.qqq.backend.core.model.actions.AbstractActionInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QQueryFilter;
@@ -53,7 +55,7 @@ public abstract class AbstractHTMLWidgetRenderer extends AbstractWidgetRenderer
    /*******************************************************************************
     **
     *******************************************************************************/
-   protected String openTopLevelBulletList()
+   public static String openTopLevelBulletList()
    {
       return ("""
          <div style="padding-left: 2rem;">
@@ -65,7 +67,7 @@ public abstract class AbstractHTMLWidgetRenderer extends AbstractWidgetRenderer
    /*******************************************************************************
     **
     *******************************************************************************/
-   protected String closeTopLevelBulletList()
+   public static String closeTopLevelBulletList()
    {
       return ("""
             </ul>
@@ -119,7 +121,7 @@ public abstract class AbstractHTMLWidgetRenderer extends AbstractWidgetRenderer
     *******************************************************************************/
    public static String linkTableBulkLoad(RenderWidgetInput input, String tableName) throws QException
    {
-      String tablePath = input.getInstance().getTablePath(input, tableName);
+      String tablePath = QContext.getQInstance().getTablePath(tableName);
       return (tablePath + "/" + tableName + ".bulkInsert");
    }
 
@@ -128,8 +130,14 @@ public abstract class AbstractHTMLWidgetRenderer extends AbstractWidgetRenderer
    /*******************************************************************************
     **
     *******************************************************************************/
-   public static String linkTableBulkLoadChildren(String tableName) throws QException
+   public static String linkTableBulkLoadChildren(RenderWidgetInput input, String tableName) throws QException
    {
+      String tablePath = QContext.getQInstance().getTablePath(tableName);
+      if(tablePath == null)
+      {
+         return (null);
+      }
+
       return ("#/launchProcess=" + tableName + ".bulkInsert");
    }
 
@@ -140,7 +148,7 @@ public abstract class AbstractHTMLWidgetRenderer extends AbstractWidgetRenderer
     *******************************************************************************/
    public static String linkTableCreate(RenderWidgetInput input, String tableName) throws QException
    {
-      String tablePath = input.getInstance().getTablePath(input, tableName);
+      String tablePath = QContext.getQInstance().getTablePath(tableName);
       return (tablePath + "/create");
    }
 
@@ -151,7 +159,7 @@ public abstract class AbstractHTMLWidgetRenderer extends AbstractWidgetRenderer
     *******************************************************************************/
    public static String linkTableCreateWithDefaultValues(RenderWidgetInput input, String tableName, Map<String, Serializable> defaultValues) throws QException
    {
-      String tablePath = input.getInstance().getTablePath(input, tableName);
+      String tablePath = QContext.getQInstance().getTablePath(tableName);
       return (tablePath + "/create?defaultValues=" + URLEncoder.encode(JsonUtils.toJson(defaultValues), Charset.defaultCharset()));
    }
 
@@ -160,9 +168,62 @@ public abstract class AbstractHTMLWidgetRenderer extends AbstractWidgetRenderer
    /*******************************************************************************
     **
     *******************************************************************************/
-   public static String linkTableFilter(RenderWidgetInput input, String tableName, QQueryFilter filter) throws QException
+   public static String getCountLink(RenderWidgetInput input, String tableName, QQueryFilter filter, int count) throws QException
    {
-      String tablePath = input.getInstance().getTablePath(input, tableName);
+      String totalString = QValueFormatter.formatValue(DisplayFormat.COMMAS, count);
+      String tablePath   = QContext.getQInstance().getTablePath(tableName);
+      if(tablePath == null || filter == null)
+      {
+         return (totalString);
+      }
+      return ("<a href='" + tablePath + "?filter=" + JsonUtils.toJson(filter) + "'>" + totalString + "</a>");
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public static void addTableFilterToListIfPermissed(RenderWidgetInput input, String tableName, List<String> urls, QQueryFilter filter) throws QException
+   {
+      String tablePath = QContext.getQInstance().getTablePath(tableName);
+      if(tablePath == null)
+      {
+         return;
+      }
+
+      urls.add(tablePath + "?filter=" + JsonUtils.toJson(filter));
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public static String linkTableFilterUnencoded(RenderWidgetInput input, String tableName, QQueryFilter filter) throws QException
+   {
+      String tablePath = QContext.getQInstance().getTablePath(tableName);
+      if(tablePath == null)
+      {
+         return (null);
+      }
+
+      return (tablePath + "?filter=" + JsonUtils.toJson(filter));
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public static String linkTableFilter(String tableName, QQueryFilter filter) throws QException
+   {
+      String tablePath = QContext.getQInstance().getTablePath(tableName);
+      if(tablePath == null)
+      {
+         return (null);
+      }
+
       return (tablePath + "?filter=" + URLEncoder.encode(JsonUtils.toJson(filter), Charset.defaultCharset()));
    }
 
@@ -171,10 +232,9 @@ public abstract class AbstractHTMLWidgetRenderer extends AbstractWidgetRenderer
    /*******************************************************************************
     **
     *******************************************************************************/
-   public static String aHrefTableFilterNoOfRecords(RenderWidgetInput input, String tableName, QQueryFilter filter, Integer noOfRecords, String singularLabel, String pluralLabel) throws QException
+   public static String aHrefTableFilterNoOfRecords(String tableName, QQueryFilter filter, Integer noOfRecords, String singularLabel, String pluralLabel) throws QException
    {
-      String href = linkTableFilter(input, tableName, filter);
-      return ("<a href=\"" + href + "\">" + QValueFormatter.formatValue(DisplayFormat.COMMAS, noOfRecords) + " " + StringUtils.plural(noOfRecords, singularLabel, pluralLabel) + "</a>");
+      return (aHrefTableFilterNoOfRecords(tableName, filter, noOfRecords, singularLabel, pluralLabel, false));
    }
 
 
@@ -182,9 +242,42 @@ public abstract class AbstractHTMLWidgetRenderer extends AbstractWidgetRenderer
    /*******************************************************************************
     **
     *******************************************************************************/
-   public static String aHrefViewRecord(RenderWidgetInput input, String tableName, Serializable id, String linkText) throws QException
+   public static String aHrefTableFilterNoOfRecords(String tableName, QQueryFilter filter, Integer noOfRecords, String singularLabel, String pluralLabel, boolean onlyLinkCount) throws QException
    {
-      return ("<a href=\"" + linkRecordView(input, tableName, id) + "\">" + linkText + "</a>");
+      String plural      = StringUtils.plural(noOfRecords, singularLabel, pluralLabel);
+      String countString = QValueFormatter.formatValue(DisplayFormat.COMMAS, noOfRecords);
+      String displayText = StringUtils.hasContent(plural) ? (" " + plural) : "";
+      String tablePath   = QContext.getQInstance().getTablePath(tableName);
+      if(tablePath == null)
+      {
+         return (countString + displayText);
+      }
+
+      String href = linkTableFilter(tableName, filter);
+      if(onlyLinkCount)
+      {
+         return ("<a href=\"" + href + "\">" + countString + "</a>" + displayText);
+      }
+      else
+      {
+         return ("<a href=\"" + href + "\">" + countString + displayText + "</a>");
+      }
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public static String aHrefViewRecord(String tableName, Serializable id, String linkText) throws QException
+   {
+      String tablePath = QContext.getQInstance().getTablePath(tableName);
+      if(tablePath == null)
+      {
+         return (linkText);
+      }
+
+      return ("<a href=\"" + linkRecordView(tableName, id) + "\">" + linkText + "</a>");
    }
 
 
@@ -194,7 +287,7 @@ public abstract class AbstractHTMLWidgetRenderer extends AbstractWidgetRenderer
     *******************************************************************************/
    public static String linkRecordEdit(AbstractActionInput input, String tableName, Serializable recordId) throws QException
    {
-      String tablePath = input.getInstance().getTablePath(input, tableName);
+      String tablePath = QContext.getQInstance().getTablePath(tableName);
       return (tablePath + "/" + recordId + "/edit");
    }
 
@@ -203,22 +296,50 @@ public abstract class AbstractHTMLWidgetRenderer extends AbstractWidgetRenderer
    /*******************************************************************************
     **
     *******************************************************************************/
-   public static String linkRecordView(AbstractActionInput input, String tableName, Serializable recordId) throws QException
+   public static String linkRecordView(String tableName, Serializable recordId) throws QException
    {
-      String tablePath = input.getInstance().getTablePath(input, tableName);
+      String tablePath = QContext.getQInstance().getTablePath(tableName);
+      if(tablePath == null)
+      {
+         return (null);
+      }
+
       return (tablePath + "/" + recordId);
    }
 
 
 
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public static String linkProcessForFilter(AbstractActionInput input, String processName, QQueryFilter filter) throws QException
+   {
+      QProcessMetaData process = QContext.getQInstance().getProcess(processName);
+      if(process == null)
+      {
+         return (null);
+      }
+      String tableName = process.getTableName();
+      if(tableName == null)
+      {
+         return (null);
+      }
+
+      String tablePath = QContext.getQInstance().getTablePath(tableName);
+      return (tablePath + "/" + processName + "?recordsParam=filterJSON&filterJSON=" + URLEncoder.encode(JsonUtils.toJson(filter), StandardCharsets.UTF_8));
+   }
+
+
+
    /*******************************************************************************
     **
     *******************************************************************************/
    public static String linkProcessForRecord(AbstractActionInput input, String processName, Serializable recordId) throws QException
    {
-      QProcessMetaData process   = input.getInstance().getProcess(processName);
+      QProcessMetaData process   = QContext.getQInstance().getProcess(processName);
       String           tableName = process.getTableName();
-      String           tablePath = input.getInstance().getTablePath(input, tableName);
+      String           tablePath = QContext.getQInstance().getTablePath(tableName);
+
       return (tablePath + "/" + recordId + "/" + processName);
    }
 
@@ -227,9 +348,9 @@ public abstract class AbstractHTMLWidgetRenderer extends AbstractWidgetRenderer
    /*******************************************************************************
     **
     *******************************************************************************/
-   public static String linkTableCreateChild(String childTableName, Map<String, Serializable> defaultValues)
+   public static String linkTableCreateChild(RenderWidgetInput input, String childTableName, Map<String, Serializable> defaultValues) throws QException
    {
-      return (linkTableCreateChild(childTableName, defaultValues, defaultValues.keySet()));
+      return (linkTableCreateChild(input, childTableName, defaultValues, defaultValues.keySet()));
    }
 
 
@@ -237,9 +358,9 @@ public abstract class AbstractHTMLWidgetRenderer extends AbstractWidgetRenderer
    /*******************************************************************************
     **
     *******************************************************************************/
-   public static String aHrefTableCreateChild(String childTableName, Map<String, Serializable> defaultValues)
+   public static String aHrefTableCreateChild(RenderWidgetInput input, String childTableName, Map<String, Serializable> defaultValues) throws QException
    {
-      return (aHrefTableCreateChild(childTableName, defaultValues, defaultValues.keySet()));
+      return (aHrefTableCreateChild(input, childTableName, defaultValues, defaultValues.keySet()));
    }
 
 
@@ -247,8 +368,14 @@ public abstract class AbstractHTMLWidgetRenderer extends AbstractWidgetRenderer
    /*******************************************************************************
     **
     *******************************************************************************/
-   public static String linkTableCreateChild(String childTableName, Map<String, Serializable> defaultValues, Set<String> disabledFields)
+   public static String linkTableCreateChild(RenderWidgetInput input, String childTableName, Map<String, Serializable> defaultValues, Set<String> disabledFields) throws QException
    {
+      String tablePath = QContext.getQInstance().getTablePath(childTableName);
+      if(tablePath == null)
+      {
+         return (null);
+      }
+
       Map<String, Integer> disabledFieldsMap = disabledFields.stream().collect(Collectors.toMap(k -> k, k -> 1));
 
       return ("#/createChild=" + childTableName
@@ -261,9 +388,35 @@ public abstract class AbstractHTMLWidgetRenderer extends AbstractWidgetRenderer
    /*******************************************************************************
     **
     *******************************************************************************/
-   public static String aHrefTableCreateChild(String childTableName, Map<String, Serializable> defaultValues, Set<String> disabledFields)
+   public static String getChipElement(String icon, String label, String color) throws QException
    {
-      return ("<a href=\"" + linkTableCreateChild(childTableName, defaultValues, defaultValues.keySet()) + "\">Create new</a>");
+      color = color != null ? color : "info";
+      color = StringUtils.ucFirst(color);
+
+      String html = "<span style='display: flex;'>";
+      html += "<div style='overflow: hidden; flex: none; display: flex; align-content: flex-start; align-items: center; height: 24px; padding-right: 8px; font-size: 13px; font-weight: 500; border: 1px solid; border-radius: 16px; color: " + color + "'>";
+      if(icon != null)
+      {
+         html += "<span style='font-size: 16px; padding: 5px' class='material-icons-round notranslate MuiIcon-root MuiIcon-fontSizeInherit MuiChip-icon MuiChip-iconSmall MuiChip-iconColor" + color + "'>" + icon + "</span>";
+      }
+      html += "<span class='MuiChip-label MuiChip-labelSmall'>" + label + "</span></div></span>";
+      return (html);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public static String aHrefTableCreateChild(RenderWidgetInput input, String childTableName, Map<String, Serializable> defaultValues, Set<String> disabledFields) throws QException
+   {
+      String tablePath = QContext.getQInstance().getTablePath(childTableName);
+      if(tablePath == null)
+      {
+         return (null);
+      }
+
+      return ("<a href=\"" + linkTableCreateChild(input, childTableName, defaultValues, defaultValues.keySet()) + "\">Create new</a>");
    }
 
 }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/dashboard/widgets/AbstractWidgetRenderer.java

@@ -25,7 +25,6 @@ package com.kingsrook.qqq.backend.core.actions.dashboard.widgets;
 import java.time.ZoneId;
 import java.time.format.DateTimeFormatter;
 import java.util.ArrayList;
-import java.util.Comparator;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
@@ -89,8 +88,7 @@ public abstract class AbstractWidgetRenderer
          pvsLabels.add(pvsLabel);
          pvsNames.add(possibleValueSourceName);
 
-         SearchPossibleValueSourceInput pvsInput = new SearchPossibleValueSourceInput(input.getInstance());
-         pvsInput.setSession(input.getSession());
+         SearchPossibleValueSourceInput pvsInput = new SearchPossibleValueSourceInput();
          pvsInput.setPossibleValueSourceName(possibleValueSourceName);
 
          if(dropdownData.getForeignKeyFieldName() != null)
@@ -123,7 +121,6 @@ public abstract class AbstractWidgetRenderer
          //////////////////////////////////////////
          Set<String> exists = new HashSet<>();
          output.getResults().removeIf(pvs -> !exists.add(pvs.getLabel()));
-         output.getResults().sort(Comparator.comparing(QPossibleValue::getLabel));
          for(QPossibleValue<?> possibleValue : output.getResults())
          {
             dropdownOptionList.add(Map.of(

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/dashboard/widgets/ChildRecordListRenderer.java

@@ -30,10 +30,13 @@ import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import com.kingsrook.qqq.backend.core.actions.tables.CountAction;
 import com.kingsrook.qqq.backend.core.actions.tables.GetAction;
 import com.kingsrook.qqq.backend.core.actions.tables.QueryAction;
+import com.kingsrook.qqq.backend.core.actions.values.QValueFormatter;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
 import com.kingsrook.qqq.backend.core.exceptions.QNotFoundException;
+import com.kingsrook.qqq.backend.core.model.actions.tables.count.CountInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.get.GetInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.get.GetOutput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QCriteriaOperator;
@@ -53,6 +56,7 @@ import com.kingsrook.qqq.backend.core.model.metadata.joins.JoinOn;
 import com.kingsrook.qqq.backend.core.model.metadata.joins.QJoinMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
 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.lang.BooleanUtils;
 
@@ -70,7 +74,8 @@ public class ChildRecordListRenderer extends AbstractWidgetRenderer
    {
       return (new Builder(new QWidgetMetaData()
          .withName(join.getName())
-         .withCodeReference(new QCodeReference(ChildRecordListRenderer.class, null))
+         .withIsCard(true)
+         .withCodeReference(new QCodeReference(ChildRecordListRenderer.class))
          .withType(WidgetType.CHILD_RECORD_LIST.getType())
          .withDefaultValue("joinName", join.getName())));
    }
@@ -116,6 +121,17 @@ public class ChildRecordListRenderer extends AbstractWidgetRenderer
 
 
 
+      /*******************************************************************************
+       **
+       *******************************************************************************/
+      public Builder withMaxRows(Integer maxRows)
+      {
+         widgetMetaData.withDefaultValue("maxRows", maxRows);
+         return (this);
+      }
+
+
+
       /*******************************************************************************
        **
        *******************************************************************************/
@@ -145,17 +161,28 @@ public class ChildRecordListRenderer extends AbstractWidgetRenderer
    @Override
    public RenderWidgetOutput render(RenderWidgetInput input) throws QException
    {
-      String        widgetLabel = input.getQueryParams().get("widgetLabel");
-      String        joinName    = input.getQueryParams().get("joinName");
-      QJoinMetaData join        = input.getInstance().getJoin(joinName);
-      String        id          = input.getQueryParams().get("id");
+      String         widgetLabel = input.getQueryParams().get("widgetLabel");
+      String         joinName    = input.getQueryParams().get("joinName");
+      QJoinMetaData  join        = input.getInstance().getJoin(joinName);
+      String         id          = input.getQueryParams().get("id");
+      QTableMetaData leftTable   = input.getInstance().getTable(join.getLeftTable());
+      QTableMetaData rightTable  = input.getInstance().getTable(join.getRightTable());
+
+      Integer maxRows = null;
+      if(StringUtils.hasContent(input.getQueryParams().get("maxRows")))
+      {
+         maxRows = ValueUtils.getValueAsInteger(input.getQueryParams().get("maxRows"));
+      }
+      else if(input.getWidgetMetaData().getDefaultValues().containsKey("maxRows"))
+      {
+         maxRows = ValueUtils.getValueAsInteger(input.getWidgetMetaData().getDefaultValues().containsKey("maxRows"));
+      }
 
       ////////////////////////////////////////////////////////
       // fetch the record that we're getting children for.  //
       // e.g., the left-side of the join, with the input id //
       ////////////////////////////////////////////////////////
-      GetInput getInput = new GetInput(input.getInstance());
-      getInput.setSession(input.getSession());
+      GetInput getInput = new GetInput();
       getInput.setTableName(join.getLeftTable());
       getInput.setPrimaryKey(id);
       GetOutput getOutput = new GetAction().execute(getInput);
@@ -163,8 +190,7 @@ public class ChildRecordListRenderer extends AbstractWidgetRenderer
 
       if(record == null)
       {
-         QTableMetaData table = input.getInstance().getTable(join.getLeftTable());
-         throw (new QNotFoundException("Could not find " + (table == null ? "" : table.getLabel()) + " with primary key " + id));
+         throw (new QNotFoundException("Could not find " + (leftTable == null ? "" : leftTable.getLabel()) + " with primary key " + id));
       }
 
       ////////////////////////////////////////////////////////////////////
@@ -176,20 +202,34 @@ public class ChildRecordListRenderer extends AbstractWidgetRenderer
          filter.addCriteria(new QFilterCriteria(joinOn.getRightField(), QCriteriaOperator.EQUALS, List.of(record.getValue(joinOn.getLeftField()))));
       }
       filter.setOrderBys(join.getOrderBys());
+      filter.setLimit(maxRows);
 
-      QueryInput queryInput = new QueryInput(input.getInstance());
-      queryInput.setSession(input.getSession());
+      QueryInput queryInput = new QueryInput();
       queryInput.setTableName(join.getRightTable());
       queryInput.setShouldTranslatePossibleValues(true);
       queryInput.setShouldGenerateDisplayValues(true);
       queryInput.setFilter(filter);
       QueryOutput queryOutput = new QueryAction().execute(queryInput);
 
-      QTableMetaData table       = input.getInstance().getTable(join.getRightTable());
-      String         tablePath   = input.getInstance().getTablePath(input, table.getName());
-      String         viewAllLink = tablePath == null ? null : (tablePath + "?filter=" + URLEncoder.encode(JsonUtils.toJson(filter), Charset.defaultCharset()));
+      QValueFormatter.setBlobValuesToDownloadUrls(rightTable, queryOutput.getRecords());
 
-      ChildRecordListData widgetData = new ChildRecordListData(widgetLabel, queryOutput, table, tablePath, viewAllLink);
+      int totalRows = queryOutput.getRecords().size();
+      if(maxRows != null && (queryOutput.getRecords().size() == maxRows))
+      {
+         /////////////////////////////////////////////////////////////////////////////////////
+         // if the input said to only do some max, and the # of results we got is that max, //
+         // then do a count query, for displaying 1-n of <count>                            //
+         /////////////////////////////////////////////////////////////////////////////////////
+         CountInput countInput = new CountInput();
+         countInput.setTableName(join.getRightTable());
+         countInput.setFilter(filter);
+         totalRows = new CountAction().execute(countInput).getCount();
+      }
+
+      String tablePath   = input.getInstance().getTablePath(rightTable.getName());
+      String viewAllLink = tablePath == null ? null : (tablePath + "?filter=" + URLEncoder.encode(JsonUtils.toJson(filter), Charset.defaultCharset()));
+
+      ChildRecordListData widgetData = new ChildRecordListData(widgetLabel, queryOutput, rightTable, tablePath, viewAllLink, totalRows);
 
       if(BooleanUtils.isTrue(ValueUtils.getValueAsBoolean(input.getQueryParams().get("canAddChildRecord"))))
       {

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/dashboard/widgets/DateTimeGroupBy.java

@@ -0,0 +1,249 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2023.  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.dashboard.widgets;
+
+
+import java.time.DayOfWeek;
+import java.time.Instant;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
+import java.time.format.DateTimeFormatter;
+import java.time.temporal.ChronoField;
+import java.time.temporal.ChronoUnit;
+import java.time.temporal.IsoFields;
+import java.time.temporal.TemporalAdjusters;
+import com.kingsrook.qqq.backend.core.utils.StringUtils;
+import com.kingsrook.qqq.backend.core.utils.ValueUtils;
+
+
+/*******************************************************************************
+ ** Enum to define various "levels" of group-by for on dashboards that want to
+ ** group records by, e.g., year, or month, or week, or day, or hour.
+ *******************************************************************************/
+public enum DateTimeGroupBy
+{
+   /////////////////////////////////////////////////////////////////////////////////////////////////////////////
+   // note - double %'s on the time format strings here, because this is a java-format string, which will get //
+   // its '%s' replaced with a column name, and so then those %'s for the date_format need escaped as %%.     //
+   // See https://www.w3schools.com/sql/func_mysql_date_format.asp for DATE_FORMAT args                       //
+   /////////////////////////////////////////////////////////////////////////////////////////////////////////////
+   YEAR("%%Y", MillisPer.YEAR, 1, ChronoUnit.YEARS, DateTimeFormatter.ofPattern("yyyy"), DateTimeFormatter.ofPattern("yyyy")),
+   MONTH("%%Y-%%m", 2 * MillisPer.MONTH, 1, ChronoUnit.MONTHS, DateTimeFormatter.ofPattern("yyyy-MM"), DateTimeFormatter.ofPattern("MMM'.' yyyy")),
+   WEEK("%%XW%%V", 35 * MillisPer.DAY, 7, ChronoUnit.DAYS, DateTimeFormatter.ofPattern("YYYY'W'ww"), DateTimeFormatter.ofPattern("YYYY'W'w")),
+   DAY("%%Y-%%m-%%d", 36 * MillisPer.HOUR, 1, ChronoUnit.DAYS, DateTimeFormatter.ofPattern("yyyy-MM-dd"), DateTimeFormatter.ofPattern("EEE'.' M'/'d")),
+   HOUR("%%Y-%%m-%%dT%%H", 0, 1, ChronoUnit.HOURS, DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH"), DateTimeFormatter.ofPattern("h a"));
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public interface MillisPer
+   {
+      long HOUR  = 60 * 60 * 1000;
+      long DAY   = 24 * HOUR;
+      long WEEK  = 7 * DAY;
+      long MONTH = 30 * DAY;
+      long YEAR  = 365 * DAY;
+   }
+
+
+
+   private final String            sqlDateFormat;
+   private final long              millisThreshold;
+   private final int               noOfChronoUnitsToAdd;
+   private final ChronoUnit        chronoUnitToAdd;
+   private final DateTimeFormatter selectedStringFormatter;
+   private final DateTimeFormatter humanStringFormatter;
+
+
+
+   /*******************************************************************************
+    ** Constructor
+    **
+    *******************************************************************************/
+   DateTimeGroupBy(String sqlDateFormat, long millisThreshold, int noOfChronoUnitsToAdd, ChronoUnit chronoUnitToAdd, DateTimeFormatter selectedStringFormatter, DateTimeFormatter humanStringFormatter)
+   {
+      this.sqlDateFormat = sqlDateFormat;
+      this.millisThreshold = millisThreshold;
+      this.noOfChronoUnitsToAdd = noOfChronoUnitsToAdd;
+      this.chronoUnitToAdd = chronoUnitToAdd;
+      this.selectedStringFormatter = selectedStringFormatter;
+      this.humanStringFormatter = humanStringFormatter;
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public String getSqlExpression()
+   {
+      ZoneId sessionOrInstanceZoneId = ValueUtils.getSessionOrInstanceZoneId();
+      String targetTimezone          = sessionOrInstanceZoneId.toString();
+
+      if("Z".equals(targetTimezone) || !StringUtils.hasContent(targetTimezone))
+      {
+         targetTimezone = "UTC";
+      }
+
+      //////////////////////////////////////////////////////////////////////////////////////////////////////
+      // if we only had a timezone offset (not a zone name/id), then the zoneId's toString will look like //
+      // UTC-05:00.  MySQL doesn't want that, so, strip away the leading UTC, to just get -05:00          //
+      //////////////////////////////////////////////////////////////////////////////////////////////////////
+      if((targetTimezone.startsWith("UTC-") || targetTimezone.startsWith("UTC+")) && targetTimezone.length() > 5)
+      {
+         targetTimezone = targetTimezone.substring(3);
+      }
+
+      return "DATE_FORMAT(CONVERT_TZ(%s, 'UTC', '" + targetTimezone + "'), '" + sqlDateFormat + "')";
+
+      /*
+      if(this == WEEK)
+      {
+         return "YEARWEEK(CONVERT_TZ(%s, 'UTC', '" + targetTimezone + "'), 6)";
+      }
+      else
+      {
+         return "DATE_FORMAT(CONVERT_TZ(%s, 'UTC', '" + targetTimezone + "'), '" + sqlDateFormat + "')";
+      }
+      */
+   }
+
+
+
+   /*******************************************************************************
+    ** get an instance of this enum, based on start & end instants - look at the #
+    ** of millis between them, and return the first enum value w/ a millisThreshold
+    ** under that difference.  Default to HOUR.
+    *******************************************************************************/
+   public static DateTimeGroupBy selectFromStartAndEndTimes(Instant start, Instant end)
+   {
+      long millisBetween = end.toEpochMilli() - start.toEpochMilli();
+      for(DateTimeGroupBy value : DateTimeGroupBy.values())
+      {
+         if(millisBetween > value.millisThreshold)
+         {
+            return (value);
+         }
+      }
+
+      return (HOUR);
+   }
+
+
+
+   /*******************************************************************************
+    ** Make an Instant into a string that will match what came out of the database's
+    ** DATE_FORMAT() function
+    *******************************************************************************/
+   public String makeSelectedString(Instant time)
+   {
+      ZonedDateTime zoned = time.atZone(ValueUtils.getSessionOrInstanceZoneId());
+
+      if(this == WEEK)
+      {
+         ////////////////////////////////////////////////////////////////////////////////////////////////////
+         // so, it seems like database is returning, e.g., W00-W52, but java is doing W1-W53...            //
+         // which, apparently we can compensate for by adding a week?  not sure, but results seemed right. //
+         ////////////////////////////////////////////////////////////////////////////////////////////////////
+         zoned = zoned.plusDays(7);
+         int weekYear = zoned.get(IsoFields.WEEK_BASED_YEAR);
+         int week     = zoned.get(IsoFields.WEEK_OF_WEEK_BASED_YEAR);
+         return (String.format("%04dW%02d", weekYear, week));
+      }
+
+      return (selectedStringFormatter.format(zoned));
+   }
+
+
+
+   /*******************************************************************************
+    ** Make a string to show to a user
+    *******************************************************************************/
+   public String makeHumanString(Instant instant)
+   {
+      ZonedDateTime zoned = instant.atZone(ValueUtils.getSessionOrInstanceZoneId());
+      if(this.equals(WEEK))
+      {
+         DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("M'/'d");
+
+         while(zoned.get(ChronoField.DAY_OF_WEEK) != DayOfWeek.SUNDAY.getValue())
+         {
+            ////////////////////////////////////////
+            // go backwards until sunday is found //
+            ////////////////////////////////////////
+            zoned = zoned.minus(1, ChronoUnit.DAYS);
+         }
+
+         return (dateTimeFormatter.format(zoned) + "-" + dateTimeFormatter.format(zoned.plusDays(6)));
+
+         /*
+         int               weekOfYear        = zoned.get(ChronoField.ALIGNED_WEEK_OF_YEAR);
+         ZonedDateTime     sunday            = zoned.with(IsoFields.WEEK_OF_WEEK_BASED_YEAR, weekOfYear).with(TemporalAdjusters.previousOrSame(DayOfWeek.SUNDAY));
+         ZonedDateTime     saturday          = sunday.with(TemporalAdjusters.next(DayOfWeek.SATURDAY));
+         DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("M'/'d");
+
+         return (dateTimeFormatter.format(sunday) + "-" + dateTimeFormatter.format(saturday));
+         */
+      }
+
+      return (humanStringFormatter.format(zoned));
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @SuppressWarnings("checkstyle:indentation")
+   public Instant roundDown(Instant instant)
+   {
+      ZonedDateTime zoned = instant.atZone(ValueUtils.getSessionOrInstanceZoneId());
+      return switch(this)
+         {
+            case YEAR -> zoned.with(TemporalAdjusters.firstDayOfYear()).truncatedTo(ChronoUnit.DAYS).toInstant();
+            case MONTH -> zoned.with(TemporalAdjusters.firstDayOfMonth()).truncatedTo(ChronoUnit.DAYS).toInstant();
+            case WEEK ->
+            {
+               while(zoned.get(ChronoField.DAY_OF_WEEK) != DayOfWeek.SUNDAY.getValue())
+               {
+                  zoned = zoned.minusDays(1);
+               }
+               yield (zoned.truncatedTo(ChronoUnit.DAYS).toInstant());
+            }
+            case DAY -> zoned.truncatedTo(ChronoUnit.DAYS).toInstant();
+            case HOUR -> zoned.truncatedTo(ChronoUnit.HOURS).toInstant();
+         };
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public Instant increment(Instant instant)
+   {
+      ZonedDateTime zoned = instant.atZone(ValueUtils.getSessionOrInstanceZoneId());
+      return (zoned.plus(noOfChronoUnitsToAdd, chronoUnitToAdd).toInstant());
+   }
+}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/dashboard/widgets/DefaultWidgetRenderer.java

@@ -0,0 +1,92 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2023.  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.dashboard.widgets;
+
+
+import java.util.Map;
+import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.model.actions.widgets.RenderWidgetInput;
+import com.kingsrook.qqq.backend.core.model.actions.widgets.RenderWidgetOutput;
+import com.kingsrook.qqq.backend.core.model.dashboard.widgets.QWidgetData;
+
+
+/*******************************************************************************
+ **
+ *******************************************************************************/
+public class DefaultWidgetRenderer extends AbstractWidgetRenderer
+{
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Override
+   public RenderWidgetOutput render(RenderWidgetInput input) throws QException
+   {
+      return new RenderWidgetOutput(new DefaultWidgetData(input));
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public static class DefaultWidgetData extends QWidgetData
+   {
+      private final String              type;
+      private final Map<String, String> queryParams;
+
+
+
+      /*******************************************************************************
+       ** Constructor
+       **
+       *******************************************************************************/
+      public DefaultWidgetData(RenderWidgetInput renderWidgetInput)
+      {
+         this.type = renderWidgetInput.getWidgetMetaData().getType();
+         this.queryParams = renderWidgetInput.getQueryParams();
+      }
+
+
+
+      /*******************************************************************************
+       **
+       *******************************************************************************/
+      @Override
+      public String getType()
+      {
+         return (type);
+      }
+
+
+
+      /*******************************************************************************
+       ** Getter for queryParams
+       **
+       *******************************************************************************/
+      public Map<String, String> getQueryParams()
+      {
+         return queryParams;
+      }
+   }
+
+}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/dashboard/widgets/NoCodeWidgetRenderer.java

@@ -0,0 +1,153 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2023.  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.dashboard.widgets;
+
+
+import java.io.Serializable;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QFilterCriteria;
+import com.kingsrook.qqq.backend.core.model.actions.widgets.RenderWidgetInput;
+import com.kingsrook.qqq.backend.core.model.actions.widgets.RenderWidgetOutput;
+import com.kingsrook.qqq.backend.core.model.dashboard.widgets.RawHTML;
+import com.kingsrook.qqq.backend.core.model.metadata.dashboard.nocode.AbstractWidgetOutput;
+import com.kingsrook.qqq.backend.core.model.metadata.dashboard.nocode.AbstractWidgetValueSource;
+import com.kingsrook.qqq.backend.core.model.metadata.dashboard.nocode.QNoCodeWidgetMetaData;
+import com.kingsrook.qqq.backend.core.modules.backend.implementations.utils.BackendQueryFilterUtils;
+import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
+import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
+
+
+/*******************************************************************************
+ **
+ *******************************************************************************/
+public class NoCodeWidgetRenderer extends AbstractWidgetRenderer
+{
+   private static final QLogger LOG = QLogger.getLogger(NoCodeWidgetRenderer.class);
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Override
+   public RenderWidgetOutput render(RenderWidgetInput input) throws QException
+   {
+      QNoCodeWidgetMetaData widgetMetaData = (QNoCodeWidgetMetaData) input.getWidgetMetaData();
+
+      Map<String, Object> context = initContext(input);
+      context.putAll(input.getQueryParams());
+
+      ///////////////////////////////////////////////
+      // populate context by evaluating all values //
+      ///////////////////////////////////////////////
+      for(AbstractWidgetValueSource valueSource : widgetMetaData.getValues())
+      {
+         try
+         {
+            LOG.trace("Computing: " + valueSource.getType() + " named " + valueSource.getName() + "...");
+            Object value = valueSource.evaluate(context, input);
+            LOG.trace("Computed: " + valueSource.getName() + " = " + value);
+            context.put(valueSource.getName(), value);
+            context.put(valueSource.getName() + ".source", valueSource);
+         }
+         catch(Exception e)
+         {
+            LOG.warn("Error evaluating widget value source", e, logPair("widgetName", input.getWidgetMetaData().getName()), logPair("valueSourceName", valueSource.getName()));
+         }
+      }
+
+      /////////////////////////////////////////////
+      // build content by evaluating all outputs //
+      /////////////////////////////////////////////
+      List<AbstractWidgetOutput> outputs = widgetMetaData.getOutputs();
+      String                     content = renderOutputs(context, outputs);
+
+      return (new RenderWidgetOutput(new RawHTML(widgetMetaData.getLabel(), content)));
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public Map<String, Object> initContext(RenderWidgetInput input)
+   {
+      Map<String, Object> context = new HashMap<>();
+      context.put("utils", new NoCodeWidgetVelocityUtils(context, input));
+      context.put("input", input);
+      return context;
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public String renderOutputs(Map<String, Object> context, List<AbstractWidgetOutput> outputs) throws QException
+   {
+      StringBuilder content = new StringBuilder();
+      for(AbstractWidgetOutput output : CollectionUtils.nonNullList(outputs))
+      {
+         boolean conditionPassed = true;
+         if(output.getCondition() != null)
+         {
+            conditionPassed = evaluateCondition(output.getCondition(), context);
+         }
+
+         if(conditionPassed)
+         {
+            String render = output.render(context);
+            content.append(render);
+            LOG.trace("Condition passed, rendered: " + render);
+         }
+         else
+         {
+            LOG.trace("Condition failed - not rendering this output.");
+         }
+      }
+      return (content.toString());
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private boolean evaluateCondition(QFilterCriteria condition, Map<String, Object> context)
+   {
+      try
+      {
+         Object value = context.get(condition.getFieldName());
+         return (BackendQueryFilterUtils.doesCriteriaMatch(condition, condition.getFieldName(), (Serializable) value));
+      }
+      catch(Exception e)
+      {
+         LOG.warn("Error evaluating condition: " + condition, e);
+         return (false);
+      }
+   }
+
+}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/dashboard/widgets/NoCodeWidgetVelocityUtils.java

@@ -0,0 +1,341 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2023.  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.dashboard.widgets;
+
+
+import java.io.Serializable;
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.time.Instant;
+import java.time.ZoneId;
+import java.util.Map;
+import com.kingsrook.qqq.backend.core.actions.dashboard.AbstractHTMLWidgetRenderer;
+import com.kingsrook.qqq.backend.core.actions.values.QValueFormatter;
+import com.kingsrook.qqq.backend.core.context.QContext;
+import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QQueryFilter;
+import com.kingsrook.qqq.backend.core.model.actions.widgets.RenderWidgetInput;
+import com.kingsrook.qqq.backend.core.model.metadata.dashboard.nocode.WidgetCount;
+import com.kingsrook.qqq.backend.core.utils.StringUtils;
+import com.kingsrook.qqq.backend.core.utils.ValueUtils;
+
+
+/*******************************************************************************
+ **
+ *******************************************************************************/
+public class NoCodeWidgetVelocityUtils
+{
+   private static final QLogger LOG = QLogger.getLogger(NoCodeWidgetVelocityUtils.class);
+
+   private Map<String, Object> context;
+   private RenderWidgetInput   input;
+
+
+
+   /*******************************************************************************
+    ** Constructor
+    **
+    *******************************************************************************/
+   public NoCodeWidgetVelocityUtils(Map<String, Object> context, RenderWidgetInput input)
+   {
+      this.context = context;
+      this.input = input;
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public String icon(String iconName, String color)
+   {
+      return String.format("""
+         <span class="material-icons-round notranslate MuiIcon-root MuiIcon-fontSizeInherit" style="color: %s; position: relative; top: 6px;" aria-hidden="true">%s</span>
+         """, color, iconName);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public String helpIcon()
+   {
+      return (icon("help_outline", "blue"));
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public String errorIcon()
+   {
+      return (icon("error_outline", "red"));
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public String warningIcon()
+   {
+      return (icon("warning", "orange"));
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public String checkIcon()
+   {
+      return (icon("check", "green"));
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public String pendingIcon()
+   {
+      return (icon("pending", "#0062ff"));
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public String spanColorGreen()
+   {
+      return ("""
+         <span style="color: green;">
+         """);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public String spanColorOrange()
+   {
+      return ("""
+         <span style="color: orange;">
+         """);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public String spanColorRed()
+   {
+      return ("""
+         <span style="color: red;">
+         """);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public String plural(Integer size, String ifOne, String ifNotOne)
+   {
+      return StringUtils.plural(size, ifOne, ifNotOne);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public String formatDateTime(Instant i)
+   {
+      if(i == null)
+      {
+         return ("");
+      }
+      return QValueFormatter.formatDateTimeWithZone(i.atZone(ZoneId.of(QContext.getQInstance().getDefaultTimeZoneId())));
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public String formatSecondsAsDuration(Integer seconds)
+   {
+      StringBuilder rs = new StringBuilder();
+
+      if(seconds == null)
+      {
+         return ("");
+      }
+
+      int secondsPerDay = 24 * 60 * 60;
+      if(seconds >= secondsPerDay)
+      {
+         int days = seconds / (secondsPerDay);
+         seconds = seconds % secondsPerDay;
+         rs.append(days).append(StringUtils.plural(days, " day", " days")).append(" ");
+      }
+
+      int secondsPerHour = 60 * 60;
+      if(seconds >= secondsPerHour)
+      {
+         int hours = seconds / (secondsPerHour);
+         seconds = seconds % secondsPerHour;
+         rs.append(hours).append(StringUtils.plural(hours, " hour", " hours")).append(" ");
+      }
+
+      int secondsPerMinute = 60;
+      if(seconds >= secondsPerMinute)
+      {
+         int minutes = seconds / (secondsPerMinute);
+         seconds = seconds % secondsPerMinute;
+         rs.append(minutes).append(StringUtils.plural(minutes, " minute", " minutes")).append(" ");
+      }
+
+      if(seconds > 0 || rs.length() == 0)
+      {
+         rs.append(seconds).append(StringUtils.plural(seconds, " second", " seconds")).append(" ");
+      }
+
+      if(rs.length() > 0)
+      {
+         rs.deleteCharAt(rs.length() - 1);
+      }
+
+      return (rs.toString());
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public String formatSecondsAsRoundedDuration(Integer seconds)
+   {
+      StringBuilder rs = new StringBuilder();
+
+      if(seconds == null)
+      {
+         return ("");
+      }
+
+      int secondsPerDay = 24 * 60 * 60;
+      if(seconds >= secondsPerDay)
+      {
+         int days = seconds / (secondsPerDay);
+         return (days + StringUtils.plural(days, " day", " days"));
+      }
+
+      int secondsPerHour = 60 * 60;
+      if(seconds >= secondsPerHour)
+      {
+         int hours = seconds / (secondsPerHour);
+         return (hours + StringUtils.plural(hours, " hour", " hours"));
+      }
+
+      int secondsPerMinute = 60;
+      if(seconds >= secondsPerMinute)
+      {
+         int minutes = seconds / (secondsPerMinute);
+         return (minutes + StringUtils.plural(minutes, " minute", " minutes"));
+      }
+
+      if(seconds > 0 || rs.length() == 0)
+      {
+         return (seconds + StringUtils.plural(seconds, " second", " seconds"));
+      }
+
+      return ("");
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public String tableCountFilterLink(String countVariableName, String singular, String plural) throws QException
+   {
+      try
+      {
+         WidgetCount  widgetCount = (WidgetCount) context.get(countVariableName + ".source");
+         Integer      count       = ValueUtils.getValueAsInteger(context.get(countVariableName));
+         QQueryFilter filter      = widgetCount.getEffectiveFilter(input);
+         return (AbstractHTMLWidgetRenderer.aHrefTableFilterNoOfRecords(widgetCount.getTableName(), filter, count, singular, plural));
+      }
+      catch(Exception e)
+      {
+         LOG.warn("Error rendering widget link", e);
+         return ("");
+      }
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public String format(String displayFormat, Serializable value)
+   {
+      return (QValueFormatter.formatValue(displayFormat, value));
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public String round(BigDecimal input, int digits)
+   {
+      return String.valueOf(input.setScale(digits, RoundingMode.HALF_UP));
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public Object ifElse(Object ifObject, Object elseObject)
+   {
+      if(StringUtils.hasContent(ValueUtils.getValueAsString(ifObject)))
+      {
+         return (ifObject);
+      }
+      else if(StringUtils.hasContent(ValueUtils.getValueAsString(elseObject)))
+      {
+         return (elseObject);
+      }
+
+      return ("");
+   }
+
+}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/interfaces/AggregateInterface.java

@@ -31,7 +31,7 @@ import com.kingsrook.qqq.backend.core.model.actions.tables.aggregate.AggregateOu
  ** Interface for the Aggregate action.
  **
  *******************************************************************************/
-public interface AggregateInterface
+public interface AggregateInterface extends BaseQueryInterface
 {
    /*******************************************************************************
     **

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/interfaces/BaseQueryInterface.java

@@ -0,0 +1,81 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2023.  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.interfaces;
+
+
+import java.time.Instant;
+import com.kingsrook.qqq.backend.core.model.querystats.QueryStat;
+
+
+/*******************************************************************************
+ ** Base class for "query" (e.g., read-operations) action interfaces (query, count, aggregate).
+ ** Initially just here for the QueryStat methods - if we expand those to apply
+ ** to insert/update/delete, well, then rename this maybe to BaseActionInterface?
+ *******************************************************************************/
+public interface BaseQueryInterface
+{
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   default void setQueryStat(QueryStat queryStat)
+   {
+      //////////
+      // noop //
+      //////////
+   }
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   default QueryStat getQueryStat()
+   {
+      return (null);
+   }
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   default void setQueryStatFirstResultTime()
+   {
+      QueryStat queryStat = getQueryStat();
+      if(queryStat != null)
+      {
+         if(queryStat.getFirstResultTimestamp() == null)
+         {
+            queryStat.setFirstResultTimestamp(Instant.now());
+         }
+      }
+   }
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   default void cancelAction()
+   {
+      //////////////////////////////////////////////
+      // initially at least, a noop in base class //
+      //////////////////////////////////////////////
+   }
+
+}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/interfaces/CountInterface.java

@@ -31,7 +31,7 @@ import com.kingsrook.qqq.backend.core.model.actions.tables.count.CountOutput;
  ** Interface for the Count action.
  **
  *******************************************************************************/
-public interface CountInterface
+public interface CountInterface extends BaseQueryInterface
 {
    /*******************************************************************************
     **

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/interfaces/DeleteInterface.java

@@ -50,4 +50,13 @@ public interface DeleteInterface
       return (false);
    }
 
+   /*******************************************************************************
+    ** Specify whether this particular module's delete action can & should fetch
+    ** records before deleting them, e.g., for audits or "not-found-checks"
+    *******************************************************************************/
+   default boolean supportsPreFetchQuery()
+   {
+      return (true);
+   }
+
 }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/interfaces/QueryInterface.java

@@ -31,10 +31,11 @@ import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryOutput;
  ** Interface for the Query action.
  **
  *******************************************************************************/
-public interface QueryInterface
+public interface QueryInterface extends BaseQueryInterface
 {
    /*******************************************************************************
     **
     *******************************************************************************/
    QueryOutput execute(QueryInput queryInput) throws QException;
+
 }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/interfaces/UpdateInterface.java

@@ -37,4 +37,14 @@ public interface UpdateInterface
     **
     *******************************************************************************/
    UpdateOutput execute(UpdateInput updateInput) throws QException;
+
+   /*******************************************************************************
+    ** Specify whether this particular module's update action can & should fetch
+    ** records before updating them, e.g., for audits or "not-found-checks"
+    *******************************************************************************/
+   default boolean supportsPreFetchQuery()
+   {
+      return (true);
+   }
+
 }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/metadata/JoinGraph.java

@@ -0,0 +1,336 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2023.  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.metadata;
+
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+import java.util.TreeSet;
+import com.kingsrook.qqq.backend.core.model.metadata.QInstance;
+import com.kingsrook.qqq.backend.core.model.metadata.joins.QJoinMetaData;
+import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
+import com.kingsrook.qqq.backend.core.utils.StringUtils;
+
+
+/*******************************************************************************
+ ** Object to represent the graph of joins in a QQQ Instance.  e.g., all of the
+ ** connections among tables through joins.
+ *******************************************************************************/
+public class JoinGraph
+{
+
+   private Set<Edge> edges = new HashSet<>();
+
+
+
+   /*******************************************************************************
+    ** Graph edge (no graph nodes needed in here)
+    *******************************************************************************/
+   private record Edge(String joinName, String leftTable, String rightTable)
+   {
+   }
+
+
+
+   /*******************************************************************************
+    ** In this class, we are treating joins as non-directional graph edges - so -
+    ** use this class to "normalize" what may otherwise be duplicated joins in the
+    ** qInstance (e.g., A -> B and B -> A -- in the instance, those are valid, but
+    ** in our graph here, we want to consider those the same).
+    *******************************************************************************/
+   private static class NormalizedJoin
+   {
+      private String tableA;
+      private String tableB;
+      private String joinFieldA;
+      private String joinFieldB;
+
+
+
+      /*******************************************************************************
+       **
+       *******************************************************************************/
+      public NormalizedJoin(QJoinMetaData joinMetaData)
+      {
+         boolean needFlip     = false;
+         int     tableCompare = joinMetaData.getLeftTable().compareTo(joinMetaData.getRightTable());
+         if(tableCompare < 0)
+         {
+            needFlip = true;
+         }
+         else if(tableCompare == 0)
+         {
+            int fieldCompare = joinMetaData.getJoinOns().get(0).getLeftField().compareTo(joinMetaData.getJoinOns().get(0).getRightField());
+            if(fieldCompare < 0)
+            {
+               needFlip = true;
+            }
+         }
+
+         if(needFlip)
+         {
+            joinMetaData = joinMetaData.flip();
+         }
+
+         tableA = joinMetaData.getLeftTable();
+         tableB = joinMetaData.getRightTable();
+         joinFieldA = joinMetaData.getJoinOns().get(0).getLeftField();
+         joinFieldB = joinMetaData.getJoinOns().get(0).getRightField();
+      }
+
+
+
+      /*******************************************************************************
+       **
+       *******************************************************************************/
+      @Override
+      public boolean equals(Object o)
+      {
+         if(this == o)
+         {
+            return true;
+         }
+         if(o == null || getClass() != o.getClass())
+         {
+            return false;
+         }
+         NormalizedJoin that = (NormalizedJoin) o;
+         return Objects.equals(tableA, that.tableA) && Objects.equals(tableB, that.tableB) && Objects.equals(joinFieldA, that.joinFieldA) && Objects.equals(joinFieldB, that.joinFieldB);
+      }
+
+
+
+      /*******************************************************************************
+       **
+       *******************************************************************************/
+      @Override
+      public int hashCode()
+      {
+         return Objects.hash(tableA, tableB, joinFieldA, joinFieldB);
+      }
+   }
+
+
+
+   /*******************************************************************************
+    ** Constructor
+    **
+    *******************************************************************************/
+   public JoinGraph(QInstance qInstance)
+   {
+      Set<NormalizedJoin> usedJoins = new HashSet<>();
+      for(QJoinMetaData join : CollectionUtils.nonNullMap(qInstance.getJoins()).values())
+      {
+         NormalizedJoin normalizedJoin = new NormalizedJoin(join);
+         if(usedJoins.contains(normalizedJoin))
+         {
+            continue;
+         }
+
+         usedJoins.add(normalizedJoin);
+         edges.add(new Edge(join.getName(), join.getLeftTable(), join.getRightTable()));
+      }
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public record JoinConnection(String joinTable, String viaJoinName) implements Comparable<JoinConnection>
+   {
+
+      /*******************************************************************************
+       **
+       *******************************************************************************/
+      @Override
+      public int compareTo(JoinConnection that)
+      {
+         Comparator<JoinConnection> comparator = Comparator.comparing((JoinConnection jc) -> jc.joinTable())
+            .thenComparing((JoinConnection jc) -> jc.viaJoinName());
+         return (comparator.compare(this, that));
+      }
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public record JoinConnectionList(List<JoinConnection> list) implements Comparable<JoinConnectionList>
+   {
+
+      /*******************************************************************************
+       **
+       *******************************************************************************/
+      public JoinConnectionList copy()
+      {
+         return new JoinConnectionList(new ArrayList<>(list));
+      }
+
+
+
+      /*******************************************************************************
+       **
+       *******************************************************************************/
+      public int compareTo(JoinConnectionList that)
+      {
+         if(this.equals(that))
+         {
+            return (0);
+         }
+
+         for(int i = 0; i < Math.min(this.list.size(), that.list.size()); i++)
+         {
+            int comp = this.list.get(i).compareTo(that.list.get(i));
+            if(comp != 0)
+            {
+               return (comp);
+            }
+         }
+
+         return (this.list.size() - that.list.size());
+      }
+
+
+
+      /*******************************************************************************
+       **
+       *******************************************************************************/
+      public boolean matchesJoinPath(List<String> joinPath)
+      {
+         if(list.size() != joinPath.size())
+         {
+            return (false);
+         }
+
+         for(int i = 0; i < list.size(); i++)
+         {
+            if(!list.get(i).viaJoinName().equals(joinPath.get(i)))
+            {
+               return (false);
+            }
+         }
+
+         return (true);
+      }
+
+
+
+      /*******************************************************************************
+       **
+       *******************************************************************************/
+      public String getJoinNamesAsString()
+      {
+         return (StringUtils.join(", ", list().stream().map(jc -> jc.viaJoinName()).toList()));
+      }
+
+
+
+      /*******************************************************************************
+       **
+       *******************************************************************************/
+      public List<String> getJoinNamesAsList()
+      {
+         return (list().stream().map(jc -> jc.viaJoinName()).toList());
+      }
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public Set<JoinConnectionList> getJoinConnections(String tableName)
+   {
+      Set<JoinConnectionList> rs = new TreeSet<>();
+      doGetJoinConnections(rs, tableName, new ArrayList<>(), new JoinConnectionList(new ArrayList<>()));
+      return (rs);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private void doGetJoinConnections(Set<JoinConnectionList> joinConnections, String tableName, List<String> path, JoinConnectionList connectionList)
+   {
+      for(Edge edge : edges)
+      {
+         if(edge.leftTable.equals(tableName) || edge.rightTable.equals(tableName))
+         {
+            if(path.contains(edge.joinName))
+            {
+               continue;
+            }
+
+            List<String> newPath = new ArrayList<>(path);
+            newPath.add(edge.joinName);
+            if(!joinConnectionsContain(joinConnections, newPath))
+            {
+               String otherTableName = null;
+               if(!edge.leftTable.equals(tableName))
+               {
+                  otherTableName = edge.leftTable;
+               }
+               else if(!edge.rightTable.equals(tableName))
+               {
+                  otherTableName = edge.rightTable;
+               }
+
+               if(otherTableName != null)
+               {
+
+                  JoinConnectionList newConnectionList = connectionList.copy();
+                  JoinConnection     joinConnection    = new JoinConnection(otherTableName, edge.joinName);
+                  newConnectionList.list.add(joinConnection);
+                  joinConnections.add(newConnectionList);
+                  doGetJoinConnections(joinConnections, otherTableName, new ArrayList<>(newPath), newConnectionList);
+               }
+            }
+         }
+      }
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private boolean joinConnectionsContain(Set<JoinConnectionList> joinPaths, List<String> newPath)
+   {
+      for(JoinConnectionList joinConnections : joinPaths)
+      {
+         List<String> joinConnectionJoins = joinConnections.list.stream().map(jc -> jc.viaJoinName).toList();
+         if(joinConnectionJoins.equals(newPath))
+         {
+            return (true);
+         }
+      }
+      return (false);
+   }
+
+}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/metadata/MetaDataAction.java

@@ -83,11 +83,14 @@ public class MetaDataAction
          }
 
          QBackendMetaData backendForTable = metaDataInput.getInstance().getBackendForTable(tableName);
-         tables.put(tableName, new QFrontendTableMetaData(metaDataInput, backendForTable, table, false));
+         tables.put(tableName, new QFrontendTableMetaData(metaDataInput, backendForTable, table, false, false));
          treeNodes.put(tableName, new AppTreeNode(table));
       }
       metaDataOutput.setTables(tables);
 
+      // addJoinsToTables(tables);
+      // addJoinedTablesToTables(tables);
+
       ////////////////////////////////////////
       // map processes to frontend metadata //
       ////////////////////////////////////////

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/metadata/TableMetaDataAction.java

@@ -54,7 +54,7 @@ public class TableMetaDataAction
          throw (new QNotFoundException("Table [" + tableMetaDataInput.getTableName() + "] was not found."));
       }
       QBackendMetaData backendForTable = tableMetaDataInput.getInstance().getBackendForTable(table.getName());
-      tableMetaDataOutput.setTable(new QFrontendTableMetaData(tableMetaDataInput, backendForTable, table, true));
+      tableMetaDataOutput.setTable(new QFrontendTableMetaData(tableMetaDataInput, backendForTable, table, true, true));
 
       // todo post-customization - can do whatever w/ the result if you want
 

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/permissions/BulkTableActionProcessPermissionChecker.java

@@ -23,11 +23,10 @@ package com.kingsrook.qqq.backend.core.actions.permissions;
 
 
 import com.kingsrook.qqq.backend.core.exceptions.QPermissionDeniedException;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
 import com.kingsrook.qqq.backend.core.model.actions.AbstractActionInput;
 import com.kingsrook.qqq.backend.core.model.actions.AbstractTableActionInput;
 import com.kingsrook.qqq.backend.core.model.metadata.permissions.MetaDataWithPermissionRules;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
 
 
 /*******************************************************************************
@@ -35,7 +34,7 @@ import org.apache.logging.log4j.Logger;
  *******************************************************************************/
 public class BulkTableActionProcessPermissionChecker implements CustomPermissionChecker
 {
-   private static final Logger LOG = LogManager.getLogger(BulkTableActionProcessPermissionChecker.class);
+   private static final QLogger LOG = QLogger.getLogger(BulkTableActionProcessPermissionChecker.class);
 
 
 
@@ -52,8 +51,7 @@ public class BulkTableActionProcessPermissionChecker implements CustomPermission
          String   tableName      = parts[0];
          String   bulkActionName = parts[1];
 
-         AbstractTableActionInput tableActionInput = new AbstractTableActionInput(actionInput.getInstance());
-         tableActionInput.setSession(actionInput.getSession());
+         AbstractTableActionInput tableActionInput = new AbstractTableActionInput();
          tableActionInput.setTableName(tableName);
 
          switch(bulkActionName)

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/permissions/PermissionsHelper.java

@@ -29,7 +29,9 @@ import java.util.LinkedHashSet;
 import java.util.Map;
 import java.util.stream.Collectors;
 import com.kingsrook.qqq.backend.core.actions.customizers.QCodeLoader;
+import com.kingsrook.qqq.backend.core.context.QContext;
 import com.kingsrook.qqq.backend.core.exceptions.QPermissionDeniedException;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
 import com.kingsrook.qqq.backend.core.model.actions.AbstractActionInput;
 import com.kingsrook.qqq.backend.core.model.actions.AbstractTableActionInput;
 import com.kingsrook.qqq.backend.core.model.metadata.QInstance;
@@ -44,8 +46,6 @@ import com.kingsrook.qqq.backend.core.model.metadata.reporting.QReportMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
 import com.kingsrook.qqq.backend.core.model.session.QSession;
 import com.kingsrook.qqq.backend.core.utils.StringUtils;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
 
 
 /*******************************************************************************
@@ -53,7 +53,7 @@ import org.apache.logging.log4j.Logger;
  *******************************************************************************/
 public class PermissionsHelper
 {
-   private static final Logger LOG = LogManager.getLogger(PermissionsHelper.class);
+   private static final QLogger LOG = QLogger.getLogger(PermissionsHelper.class);
 
 
 
@@ -73,9 +73,22 @@ public class PermissionsHelper
    private static void checkTablePermissionThrowing(AbstractActionInput actionInput, String tableName, TablePermissionSubType permissionSubType) throws QPermissionDeniedException
    {
       warnAboutPermissionSubTypeForTables(permissionSubType);
-      QTableMetaData table = actionInput.getInstance().getTable(tableName);
+      QTableMetaData table = QContext.getQInstance().getTable(tableName);
 
-      commonCheckPermissionThrowing(getEffectivePermissionRules(table, actionInput.getInstance()), permissionSubType, table.getName(), actionInput);
+      commonCheckPermissionThrowing(getEffectivePermissionRules(table, QContext.getQInstance()), permissionSubType, table.getName());
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public static String getTablePermissionName(String tableName, TablePermissionSubType permissionSubType)
+   {
+      QInstance        qInstance          = QContext.getQInstance();
+      QPermissionRules rules              = getEffectivePermissionRules(qInstance.getTable(tableName), qInstance);
+      String           permissionBaseName = getEffectivePermissionBaseName(rules, tableName);
+      return (getPermissionName(permissionBaseName, permissionSubType));
    }
 
 
@@ -103,7 +116,7 @@ public class PermissionsHelper
     *******************************************************************************/
    public static PermissionCheckResult getPermissionCheckResult(AbstractActionInput actionInput, MetaDataWithPermissionRules metaDataWithPermissionRules)
    {
-      QPermissionRules rules              = getEffectivePermissionRules(metaDataWithPermissionRules, actionInput.getInstance());
+      QPermissionRules rules              = getEffectivePermissionRules(metaDataWithPermissionRules, QContext.getQInstance());
       String           permissionBaseName = getEffectivePermissionBaseName(rules, metaDataWithPermissionRules.getName());
 
       switch(rules.getLevel())
@@ -168,8 +181,8 @@ public class PermissionsHelper
     *******************************************************************************/
    public static void checkProcessPermissionThrowing(AbstractActionInput actionInput, String processName, Map<String, Serializable> processValues) throws QPermissionDeniedException
    {
-      QProcessMetaData process                  = actionInput.getInstance().getProcess(processName);
-      QPermissionRules effectivePermissionRules = getEffectivePermissionRules(process, actionInput.getInstance());
+      QProcessMetaData process                  = QContext.getQInstance().getProcess(processName);
+      QPermissionRules effectivePermissionRules = getEffectivePermissionRules(process, QContext.getQInstance());
 
       if(effectivePermissionRules.getCustomPermissionChecker() != null)
       {
@@ -181,7 +194,7 @@ public class PermissionsHelper
          return;
       }
 
-      commonCheckPermissionThrowing(effectivePermissionRules, PrivatePermissionSubType.HAS_ACCESS, process.getName(), actionInput);
+      commonCheckPermissionThrowing(effectivePermissionRules, PrivatePermissionSubType.HAS_ACCESS, process.getName());
    }
 
 
@@ -209,8 +222,8 @@ public class PermissionsHelper
     *******************************************************************************/
    public static void checkAppPermissionThrowing(AbstractActionInput actionInput, String appName) throws QPermissionDeniedException
    {
-      QAppMetaData app = actionInput.getInstance().getApp(appName);
-      commonCheckPermissionThrowing(getEffectivePermissionRules(app, actionInput.getInstance()), PrivatePermissionSubType.HAS_ACCESS, app.getName(), actionInput);
+      QAppMetaData app = QContext.getQInstance().getApp(appName);
+      commonCheckPermissionThrowing(getEffectivePermissionRules(app, QContext.getQInstance()), PrivatePermissionSubType.HAS_ACCESS, app.getName());
    }
 
 
@@ -238,8 +251,8 @@ public class PermissionsHelper
     *******************************************************************************/
    public static void checkReportPermissionThrowing(AbstractActionInput actionInput, String reportName) throws QPermissionDeniedException
    {
-      QReportMetaData report = actionInput.getInstance().getReport(reportName);
-      commonCheckPermissionThrowing(getEffectivePermissionRules(report, actionInput.getInstance()), PrivatePermissionSubType.HAS_ACCESS, report.getName(), actionInput);
+      QReportMetaData report = QContext.getQInstance().getReport(reportName);
+      commonCheckPermissionThrowing(getEffectivePermissionRules(report, QContext.getQInstance()), PrivatePermissionSubType.HAS_ACCESS, report.getName());
    }
 
 
@@ -267,8 +280,8 @@ public class PermissionsHelper
     *******************************************************************************/
    public static void checkWidgetPermissionThrowing(AbstractActionInput actionInput, String widgetName) throws QPermissionDeniedException
    {
-      QWidgetMetaDataInterface widget = actionInput.getInstance().getWidget(widgetName);
-      commonCheckPermissionThrowing(getEffectivePermissionRules(widget, actionInput.getInstance()), PrivatePermissionSubType.HAS_ACCESS, widget.getName(), actionInput);
+      QWidgetMetaDataInterface widget = QContext.getQInstance().getWidget(widgetName);
+      commonCheckPermissionThrowing(getEffectivePermissionRules(widget, QContext.getQInstance()), PrivatePermissionSubType.HAS_ACCESS, widget.getName());
    }
 
 
@@ -387,6 +400,11 @@ public class PermissionsHelper
     *******************************************************************************/
    public static QPermissionRules getEffectivePermissionRules(MetaDataWithPermissionRules metaDataWithPermissionRules, QInstance instance)
    {
+      if(metaDataWithPermissionRules.getPermissionRules() == null)
+      {
+         LOG.warn("Null permission rules on meta data object [" + metaDataWithPermissionRules.getClass().getSimpleName() + "][" + metaDataWithPermissionRules.getName() + "] - does the instance need enriched?  Returning instance default rules.");
+         return (instance.getDefaultPermissionRules());
+      }
       return (metaDataWithPermissionRules.getPermissionRules());
    }
 
@@ -431,7 +449,7 @@ public class PermissionsHelper
             }
          }
 
-         if(hasPermission(actionInput.getSession(), permissionBaseName, effectivePermissionSubType))
+         if(hasPermission(QContext.getQSession(), permissionBaseName, effectivePermissionSubType))
          {
             return (PermissionCheckResult.ALLOW);
          }
@@ -519,7 +537,7 @@ public class PermissionsHelper
    /*******************************************************************************
     **
     *******************************************************************************/
-   private static void commonCheckPermissionThrowing(QPermissionRules rules, PermissionSubType permissionSubType, String name, AbstractActionInput actionInput) throws QPermissionDeniedException
+   private static void commonCheckPermissionThrowing(QPermissionRules rules, PermissionSubType permissionSubType, String name) throws QPermissionDeniedException
    {
       PermissionSubType effectivePermissionSubType = getEffectivePermissionSubType(rules, permissionSubType);
       String            permissionBaseName         = getEffectivePermissionBaseName(rules, name);
@@ -529,9 +547,9 @@ public class PermissionsHelper
          return;
       }
 
-      if(!hasPermission(actionInput.getSession(), permissionBaseName, effectivePermissionSubType))
+      if(!hasPermission(QContext.getQSession(), permissionBaseName, effectivePermissionSubType))
       {
-         // LOG.debug("Throwing permission denied for: " + getPermissionName(permissionBaseName, effectivePermissionSubType) + " for " + actionInput.getSession().getUser());
+         // LOG.debug("Throwing permission denied for: " + getPermissionName(permissionBaseName, effectivePermissionSubType) + " for " + QContext.getQSession().getUser());
          throw (new QPermissionDeniedException("Permission denied."));
       }
    }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/processes/RunBackendStepAction.java

@@ -31,6 +31,7 @@ import com.kingsrook.qqq.backend.core.actions.ActionHelper;
 import com.kingsrook.qqq.backend.core.actions.tables.QueryAction;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
 import com.kingsrook.qqq.backend.core.exceptions.QUserFacingException;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
 import com.kingsrook.qqq.backend.core.model.actions.processes.RunBackendStepInput;
 import com.kingsrook.qqq.backend.core.model.actions.processes.RunBackendStepOutput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryInput;
@@ -42,8 +43,6 @@ import com.kingsrook.qqq.backend.core.model.metadata.processes.QFunctionInputMet
 import com.kingsrook.qqq.backend.core.model.metadata.processes.QProcessMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.processes.QStepMetaData;
 import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
 
 
 /*******************************************************************************
@@ -52,7 +51,7 @@ import org.apache.logging.log4j.Logger;
  *******************************************************************************/
 public class RunBackendStepAction
 {
-   private static final Logger LOG = LogManager.getLogger(RunBackendStepAction.class);
+   private static final QLogger LOG = QLogger.getLogger(RunBackendStepAction.class);
 
 
 
@@ -107,7 +106,7 @@ public class RunBackendStepAction
          return;
       }
 
-      List<QFieldMetaData> fieldsToGet = new ArrayList<>();
+      List<QFieldMetaData> fieldsToGet           = new ArrayList<>();
       List<QFieldMetaData> requiredFieldsMissing = new ArrayList<>();
       for(QFieldMetaData field : inputMetaData.getFieldList())
       {
@@ -175,8 +174,7 @@ public class RunBackendStepAction
       {
          if(CollectionUtils.nullSafeIsEmpty(runBackendStepInput.getRecords()))
          {
-            QueryInput queryInput = new QueryInput(runBackendStepInput.getInstance());
-            queryInput.setSession(runBackendStepInput.getSession());
+            QueryInput queryInput = new QueryInput();
             queryInput.setTableName(inputMetaData.getRecordListMetaData().getTableName());
 
             // todo - handle this being async (e.g., http)

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/processes/RunProcessAction.java

@@ -31,10 +31,13 @@ import java.util.Map;
 import java.util.Optional;
 import java.util.UUID;
 import com.kingsrook.qqq.backend.core.actions.ActionHelper;
+import com.kingsrook.qqq.backend.core.actions.dashboard.widgets.NoCodeWidgetRenderer;
 import com.kingsrook.qqq.backend.core.actions.tables.InsertAction;
 import com.kingsrook.qqq.backend.core.actions.tables.QueryAction;
 import com.kingsrook.qqq.backend.core.actions.tables.UpdateAction;
+import com.kingsrook.qqq.backend.core.context.QContext;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
 import com.kingsrook.qqq.backend.core.model.actions.processes.ProcessState;
 import com.kingsrook.qqq.backend.core.model.actions.processes.RunBackendStepInput;
 import com.kingsrook.qqq.backend.core.model.actions.processes.RunBackendStepOutput;
@@ -48,20 +51,24 @@ import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryOutput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.update.UpdateInput;
 import com.kingsrook.qqq.backend.core.model.data.QRecord;
+import com.kingsrook.qqq.backend.core.model.metadata.QBackendMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.fields.QFieldMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.processes.NoCodeWidgetFrontendComponentMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.processes.QBackendStepMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.processes.QFrontendComponentMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.processes.QFrontendStepMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.processes.QProcessMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.processes.QStepMetaData;
+import com.kingsrook.qqq.backend.core.model.session.QSession;
 import com.kingsrook.qqq.backend.core.processes.implementations.basepull.BasepullConfiguration;
 import com.kingsrook.qqq.backend.core.state.InMemoryStateProvider;
 import com.kingsrook.qqq.backend.core.state.StateProviderInterface;
 import com.kingsrook.qqq.backend.core.state.StateType;
 import com.kingsrook.qqq.backend.core.state.UUIDAndTypeStateKey;
 import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
+import com.kingsrook.qqq.backend.core.utils.StringUtils;
 import com.kingsrook.qqq.backend.core.utils.ValueUtils;
 import org.apache.commons.lang.BooleanUtils;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
 
 
 /*******************************************************************************
@@ -70,7 +77,7 @@ import org.apache.logging.log4j.Logger;
  *******************************************************************************/
 public class RunProcessAction
 {
-   private static final Logger LOG = LogManager.getLogger(RunProcessAction.class);
+   private static final QLogger LOG = QLogger.getLogger(RunProcessAction.class);
 
    public static final String BASEPULL_THIS_RUNTIME_KEY = "basepullThisRuntimeKey";
    public static final String BASEPULL_LAST_RUNTIME_KEY = "basepullLastRuntimeKey";
@@ -143,7 +150,7 @@ public class RunProcessAction
             QStepMetaData step = stepList.get(0);
             lastStepName = step.getName();
 
-            if(step instanceof QFrontendStepMetaData)
+            if(step instanceof QFrontendStepMetaData frontendStep)
             {
                ////////////////////////////////////////////////////////////////
                // Handle what to do with frontend steps, per request setting //
@@ -153,6 +160,8 @@ public class RunProcessAction
                   case BREAK ->
                   {
                      LOG.trace("Breaking process [" + process.getName() + "] at frontend step (as requested by caller): " + step.getName());
+                     processFrontendStepFieldDefaultValues(processState, frontendStep);
+                     processFrontendComponents(processState, frontendStep);
                      processState.setNextStepName(step.getName());
                      break STEP_LOOP;
                   }
@@ -230,6 +239,42 @@ public class RunProcessAction
 
 
 
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private void processFrontendComponents(ProcessState processState, QFrontendStepMetaData frontendStep) throws QException
+   {
+      for(QFrontendComponentMetaData component : CollectionUtils.nonNullList(frontendStep.getComponents()))
+      {
+         if(component instanceof NoCodeWidgetFrontendComponentMetaData noCodeWidgetComponent)
+         {
+            NoCodeWidgetRenderer noCodeWidgetRenderer = new NoCodeWidgetRenderer();
+            Map<String, Object>  context              = noCodeWidgetRenderer.initContext(null);
+            context.putAll(processState.getValues());
+            String html = noCodeWidgetRenderer.renderOutputs(context, noCodeWidgetComponent.getOutputs());
+            processState.getValues().put(frontendStep.getName() + ".html", html);
+         }
+      }
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private void processFrontendStepFieldDefaultValues(ProcessState processState, QFrontendStepMetaData step)
+   {
+      for(QFieldMetaData formField : CollectionUtils.mergeLists(step.getFormFields(), step.getInputFields(), step.getViewFields(), step.getOutputFields()))
+      {
+         if(formField.getDefaultValue() != null && processState.getValues().get(formField.getName()) == null)
+         {
+            processState.getValues().put(formField.getName(), formField.getDefaultValue());
+         }
+      }
+   }
+
+
+
    /*******************************************************************************
     ** When we start running a process (or resuming it), get data in the RunProcessRequest
     ** either from the state provider (if they're found, for a resume).
@@ -295,15 +340,25 @@ public class RunProcessAction
     *******************************************************************************/
    private void runBackendStep(RunProcessInput runProcessInput, QProcessMetaData process, RunProcessOutput runProcessOutput, UUIDAndTypeStateKey stateKey, QBackendStepMetaData backendStep, QProcessMetaData qProcessMetaData, ProcessState processState) throws Exception
    {
-      RunBackendStepInput runBackendStepInput = new RunBackendStepInput(runProcessInput.getInstance(), processState);
+      RunBackendStepInput runBackendStepInput = new RunBackendStepInput(processState);
       runBackendStepInput.setProcessName(process.getName());
       runBackendStepInput.setStepName(backendStep.getName());
-      runBackendStepInput.setTableName(process.getTableName());
-      runBackendStepInput.setSession(runProcessInput.getSession());
       runBackendStepInput.setCallback(runProcessInput.getCallback());
       runBackendStepInput.setFrontendStepBehavior(runProcessInput.getFrontendStepBehavior());
       runBackendStepInput.setAsyncJobCallback(runProcessInput.getAsyncJobCallback());
 
+      runBackendStepInput.setTableName(process.getTableName());
+      if(!StringUtils.hasContent(runBackendStepInput.getTableName()))
+      {
+         ////////////////////////////////////////////////////////////////
+         // help support generic (e.g., not tied-to-a-table) processes //
+         ////////////////////////////////////////////////////////////////
+         if(runProcessInput.getValue("tableName") != null)
+         {
+            runBackendStepInput.setTableName(ValueUtils.getValueAsString(runProcessInput.getValue("tableName")));
+         }
+      }
+
       ///////////////////////////////////////////////////////////////
       // if 'basepull' values are in the inputs, add to step input //
       ///////////////////////////////////////////////////////////////
@@ -431,6 +486,35 @@ public class RunProcessAction
 
 
 
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   protected String determineBasepullKeyValue(QProcessMetaData process, BasepullConfiguration basepullConfiguration) throws QException
+   {
+      String basepullKeyValue = (basepullConfiguration.getKeyValue() != null) ? basepullConfiguration.getKeyValue() : process.getName();
+
+      //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // if backend specifies that it uses variants, look for that data in the session and append to our basepull key //
+      //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      if(process.getSchedule() != null && process.getSchedule().getVariantBackend() != null)
+      {
+         QSession         session         = QContext.getQSession();
+         QBackendMetaData backendMetaData = QContext.getQInstance().getBackend(process.getSchedule().getVariantBackend());
+         if(session.getBackendVariants() == null || !session.getBackendVariants().containsKey(backendMetaData.getVariantOptionsTableTypeValue()))
+         {
+            LOG.info("Could not find Backend Variant information for Backend '" + backendMetaData.getName() + "'");
+         }
+         else
+         {
+            basepullKeyValue += "-" + session.getBackendVariants().get(backendMetaData.getVariantOptionsTableTypeValue());
+         }
+      }
+
+      return (basepullKeyValue);
+   }
+
+
+
    /*******************************************************************************
     ** Insert or update the last runtime value for this basepull into the backend.
     *******************************************************************************/
@@ -439,13 +523,12 @@ public class RunProcessAction
       String basepullTableName            = basepullConfiguration.getTableName();
       String basepullKeyFieldName         = basepullConfiguration.getKeyField();
       String basepullLastRunTimeFieldName = basepullConfiguration.getLastRunTimeFieldName();
-      String basepullKeyValue             = (basepullConfiguration.getKeyValue() != null) ? basepullConfiguration.getKeyValue() : process.getName();
+      String basepullKeyValue             = determineBasepullKeyValue(process, basepullConfiguration);
 
       ///////////////////////////////////////
       // get the stored basepull timestamp //
       ///////////////////////////////////////
-      QueryInput queryInput = new QueryInput(runProcessInput.getInstance());
-      queryInput.setSession(runProcessInput.getSession());
+      QueryInput queryInput = new QueryInput();
       queryInput.setTableName(basepullTableName);
       queryInput.setFilter(new QQueryFilter().withCriteria(
          new QFilterCriteria()
@@ -473,8 +556,7 @@ public class RunProcessAction
          ////////////
          // update //
          ////////////
-         UpdateInput updateInput = new UpdateInput(runProcessInput.getInstance());
-         updateInput.setSession(runProcessInput.getSession());
+         UpdateInput updateInput = new UpdateInput();
          updateInput.setTableName(basepullTableName);
          updateInput.setRecords(List.of(basepullRecord));
          new UpdateAction().execute(updateInput);
@@ -488,8 +570,7 @@ public class RunProcessAction
          ////////////////////////////////
          // insert new basepull record //
          ////////////////////////////////
-         InsertInput insertInput = new InsertInput(runProcessInput.getInstance());
-         insertInput.setSession(runProcessInput.getSession());
+         InsertInput insertInput = new InsertInput();
          insertInput.setTableName(basepullTableName);
          insertInput.setRecords(List.of(basepullRecord));
          new InsertAction().execute(insertInput);
@@ -522,13 +603,12 @@ public class RunProcessAction
       String  basepullKeyFieldName                 = basepullConfiguration.getKeyField();
       String  basepullLastRunTimeFieldName         = basepullConfiguration.getLastRunTimeFieldName();
       Integer basepullHoursBackForInitialTimestamp = basepullConfiguration.getHoursBackForInitialTimestamp();
-      String  basepullKeyValue                     = (basepullConfiguration.getKeyValue() != null) ? basepullConfiguration.getKeyValue() : process.getName();
+      String  basepullKeyValue                     = determineBasepullKeyValue(process, basepullConfiguration);
 
       ///////////////////////////////////////
       // get the stored basepull timestamp //
       ///////////////////////////////////////
-      QueryInput queryInput = new QueryInput(runProcessInput.getInstance());
-      queryInput.setSession(runProcessInput.getSession());
+      QueryInput queryInput = new QueryInput();
       queryInput.setTableName(basepullTableName);
       queryInput.setFilter(new QQueryFilter().withCriteria(
          new QFilterCriteria()

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/queues/GetQueueSize.java

@@ -0,0 +1,84 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2023.  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.queues;
+
+
+import java.util.List;
+import com.amazonaws.auth.AWSStaticCredentialsProvider;
+import com.amazonaws.auth.BasicAWSCredentials;
+import com.amazonaws.services.sqs.AmazonSQS;
+import com.amazonaws.services.sqs.AmazonSQSClientBuilder;
+import com.amazonaws.services.sqs.model.GetQueueAttributesResult;
+import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
+import com.kingsrook.qqq.backend.core.model.metadata.queues.QQueueMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.queues.QQueueProviderMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.queues.SQSQueueProviderMetaData;
+import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
+
+
+/*******************************************************************************
+ **
+ *******************************************************************************/
+public class GetQueueSize
+{
+   private static final QLogger LOG = QLogger.getLogger(GetQueueSize.class);
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public Integer getQueueSize(QQueueProviderMetaData queueProviderMetaData, QQueueMetaData queueMetaData) throws QException
+   {
+      try
+      {
+         //////////////////////////////////////////////////////////////////
+         // todo - handle other queue provider types, somewhere, somehow //
+         //////////////////////////////////////////////////////////////////
+         SQSQueueProviderMetaData queueProvider = (SQSQueueProviderMetaData) queueProviderMetaData;
+
+         BasicAWSCredentials credentials = new BasicAWSCredentials(queueProvider.getAccessKey(), queueProvider.getSecretKey());
+         final AmazonSQS sqs = AmazonSQSClientBuilder.standard()
+            .withRegion(queueProvider.getRegion())
+            .withCredentials(new AWSStaticCredentialsProvider(credentials))
+            .build();
+
+         String queueUrl = queueProvider.getBaseURL();
+         if(!queueUrl.endsWith("/"))
+         {
+            queueUrl += "/";
+         }
+         queueUrl += queueMetaData.getQueueName();
+
+         GetQueueAttributesResult queueAttributes             = sqs.getQueueAttributes(queueUrl, List.of("ApproximateNumberOfMessages"));
+         String                   approximateNumberOfMessages = queueAttributes.getAttributes().get("ApproximateNumberOfMessages");
+         return (Integer.parseInt(approximateNumberOfMessages));
+      }
+      catch(Exception e)
+      {
+         LOG.warn("Error getting queue size", e, logPair("queueName", queueMetaData == null ? "null" : queueMetaData.getName()));
+         throw (new QException("Error getting queue size", e));
+      }
+   }
+
+}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/queues/SQSQueuePoller.java

@@ -35,15 +35,14 @@ import com.amazonaws.services.sqs.model.Message;
 import com.amazonaws.services.sqs.model.ReceiveMessageRequest;
 import com.amazonaws.services.sqs.model.ReceiveMessageResult;
 import com.kingsrook.qqq.backend.core.actions.processes.RunProcessAction;
+import com.kingsrook.qqq.backend.core.context.QContext;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
 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.metadata.QInstance;
 import com.kingsrook.qqq.backend.core.model.metadata.queues.QQueueMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.queues.SQSQueueProviderMetaData;
 import com.kingsrook.qqq.backend.core.model.session.QSession;
-import com.kingsrook.qqq.backend.core.scheduler.StandardScheduledExecutor;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
 
 
 /*******************************************************************************
@@ -51,7 +50,7 @@ import org.apache.logging.log4j.Logger;
  *******************************************************************************/
 public class SQSQueuePoller implements Runnable
 {
-   private static final Logger LOG = LogManager.getLogger(SQSQueuePoller.class);
+   private static final QLogger LOG = QLogger.getLogger(SQSQueuePoller.class);
 
    ///////////////////////////////////////////////
    // todo - move these 2 to a "QBaseRunnable"? //
@@ -70,8 +69,10 @@ public class SQSQueuePoller implements Runnable
    @Override
    public void run()
    {
+      QContext.init(qInstance, sessionSupplier.get());
+
       String originalThreadName = Thread.currentThread().getName();
-      Thread.currentThread().setName("SQSPoller>" + queueMetaData.getName() + StandardScheduledExecutor.newThreadNameRandomSuffix());
+      Thread.currentThread().setName("SQSPoller>" + queueMetaData.getName());
       LOG.debug("Running " + this.getClass().getSimpleName() + "[" + queueMetaData.getName() + "]");
 
       try
@@ -125,12 +126,13 @@ public class SQSQueuePoller implements Runnable
             /////////////////////////////////////////////////////////////////////////////////////
             try
             {
-               RunProcessInput runProcessInput = new RunProcessInput(qInstance);
-               runProcessInput.setSession(sessionSupplier.get());
+               RunProcessInput runProcessInput = new RunProcessInput();
                runProcessInput.setProcessName(queueMetaData.getProcessName());
                runProcessInput.setFrontendStepBehavior(RunProcessInput.FrontendStepBehavior.SKIP);
                runProcessInput.addValue("bodies", bodies);
 
+               QContext.pushAction(runProcessInput);
+
                RunProcessAction runProcessAction = new RunProcessAction();
                RunProcessOutput runProcessOutput = runProcessAction.execute(runProcessInput);
 
@@ -156,6 +158,10 @@ public class SQSQueuePoller implements Runnable
             {
                LOG.warn("Error receiving SQS Messages.", e);
             }
+            finally
+            {
+               QContext.popAction();
+            }
          }
       }
       catch(Exception e)
@@ -165,6 +171,7 @@ public class SQSQueuePoller implements Runnable
       finally
       {
          Thread.currentThread().setName(originalThreadName);
+         QContext.clear();
       }
    }
 

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/reporting/BufferedRecordPipe.java

@@ -24,6 +24,7 @@ package com.kingsrook.qqq.backend.core.actions.reporting;
 
 import java.util.ArrayList;
 import java.util.List;
+import com.kingsrook.qqq.backend.core.exceptions.QException;
 import com.kingsrook.qqq.backend.core.model.data.QRecord;
 
 
@@ -63,7 +64,7 @@ public class BufferedRecordPipe extends RecordPipe
     **
     *******************************************************************************/
    @Override
-   public void addRecord(QRecord record)
+   public void addRecord(QRecord record) throws QException
    {
       buffer.add(record);
       if(buffer.size() >= bufferSize)
@@ -78,7 +79,7 @@ public class BufferedRecordPipe extends RecordPipe
    /*******************************************************************************
     **
     *******************************************************************************/
-   public void finalFlush()
+   public void finalFlush() throws QException
    {
       if(!buffer.isEmpty())
       {

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/reporting/CsvExportStreamer.java

@@ -27,13 +27,12 @@ import java.nio.charset.StandardCharsets;
 import java.util.List;
 import com.kingsrook.qqq.backend.core.adapters.QRecordToCsvAdapter;
 import com.kingsrook.qqq.backend.core.exceptions.QReportingException;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
 import com.kingsrook.qqq.backend.core.model.actions.reporting.ExportInput;
 import com.kingsrook.qqq.backend.core.model.data.QRecord;
 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.utils.StringUtils;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
 
 
 /*******************************************************************************
@@ -41,7 +40,7 @@ import org.apache.logging.log4j.Logger;
  *******************************************************************************/
 public class CsvExportStreamer implements ExportStreamerInterface
 {
-   private static final Logger LOG = LogManager.getLogger(CsvExportStreamer.class);
+   private static final QLogger LOG = QLogger.getLogger(CsvExportStreamer.class);
 
    private final QRecordToCsvAdapter qRecordToCsvAdapter;
 

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/reporting/ExcelExportStreamer.java

@@ -37,6 +37,7 @@ import java.util.Objects;
 import com.kingsrook.qqq.backend.core.actions.reporting.excelformatting.ExcelStylerInterface;
 import com.kingsrook.qqq.backend.core.actions.reporting.excelformatting.PlainExcelStyler;
 import com.kingsrook.qqq.backend.core.exceptions.QReportingException;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
 import com.kingsrook.qqq.backend.core.model.actions.reporting.ExportInput;
 import com.kingsrook.qqq.backend.core.model.data.QRecord;
 import com.kingsrook.qqq.backend.core.model.metadata.QInstance;
@@ -45,8 +46,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.utils.StringUtils;
 import com.kingsrook.qqq.backend.core.utils.ValueUtils;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
 import org.dhatim.fastexcel.StyleSetter;
 import org.dhatim.fastexcel.Workbook;
 import org.dhatim.fastexcel.Worksheet;
@@ -57,7 +56,7 @@ import org.dhatim.fastexcel.Worksheet;
  *******************************************************************************/
 public class ExcelExportStreamer implements ExportStreamerInterface
 {
-   private static final Logger LOG = LogManager.getLogger(ExcelExportStreamer.class);
+   private static final QLogger LOG = QLogger.getLogger(ExcelExportStreamer.class);
 
    private ExportInput          exportInput;
    private QTableMetaData       table;

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/reporting/ExportAction.java

@@ -23,8 +23,12 @@ package com.kingsrook.qqq.backend.core.actions.reporting;
 
 
 import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Optional;
+import java.util.Set;
 import java.util.concurrent.TimeUnit;
 import com.kingsrook.qqq.backend.core.actions.ActionHelper;
 import com.kingsrook.qqq.backend.core.actions.async.AsyncJobManager;
@@ -32,26 +36,29 @@ import com.kingsrook.qqq.backend.core.actions.async.AsyncJobState;
 import com.kingsrook.qqq.backend.core.actions.async.AsyncJobStatus;
 import com.kingsrook.qqq.backend.core.actions.interfaces.CountInterface;
 import com.kingsrook.qqq.backend.core.actions.tables.QueryAction;
+import com.kingsrook.qqq.backend.core.context.QContext;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
 import com.kingsrook.qqq.backend.core.exceptions.QReportingException;
 import com.kingsrook.qqq.backend.core.exceptions.QUserFacingException;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
 import com.kingsrook.qqq.backend.core.model.actions.reporting.ExportInput;
 import com.kingsrook.qqq.backend.core.model.actions.reporting.ExportOutput;
 import com.kingsrook.qqq.backend.core.model.actions.reporting.ReportFormat;
 import com.kingsrook.qqq.backend.core.model.actions.tables.count.CountInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.count.CountOutput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QQueryFilter;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryJoin;
 import com.kingsrook.qqq.backend.core.model.data.QRecord;
 import com.kingsrook.qqq.backend.core.model.metadata.fields.QFieldMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.fields.QFieldType;
+import com.kingsrook.qqq.backend.core.model.metadata.tables.ExposedJoin;
 import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
 import com.kingsrook.qqq.backend.core.modules.backend.QBackendModuleDispatcher;
 import com.kingsrook.qqq.backend.core.modules.backend.QBackendModuleInterface;
 import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
 import com.kingsrook.qqq.backend.core.utils.SleepUtils;
 import com.kingsrook.qqq.backend.core.utils.StringUtils;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
 
 
 /*******************************************************************************
@@ -67,7 +74,7 @@ import org.apache.logging.log4j.Logger;
  *******************************************************************************/
 public class ExportAction
 {
-   private static final Logger LOG = LogManager.getLogger(ExportAction.class);
+   private static final QLogger LOG = QLogger.getLogger(ExportAction.class);
 
    private boolean preExecuteRan       = false;
    private Integer countFromPreExecute = null;
@@ -96,15 +103,25 @@ public class ExportAction
       ///////////////////////////////////
       if(CollectionUtils.nullSafeHasContents(exportInput.getFieldNames()))
       {
-         QTableMetaData table         = exportInput.getTable();
-         List<String>   badFieldNames = new ArrayList<>();
+         QTableMetaData              table        = exportInput.getTable();
+         Map<String, QTableMetaData> joinTableMap = getJoinTableMap(table);
+
+         List<String> badFieldNames = new ArrayList<>();
          for(String fieldName : exportInput.getFieldNames())
          {
             try
             {
-               table.getField(fieldName);
+               if(fieldName.contains("."))
+               {
+                  String[] parts = fieldName.split("\\.", 2);
+                  joinTableMap.get(parts[0]).getField(parts[1]);
+               }
+               else
+               {
+                  table.getField(fieldName);
+               }
             }
-            catch(IllegalArgumentException iae)
+            catch(Exception e)
             {
                badFieldNames.add(fieldName);
             }
@@ -129,6 +146,21 @@ public class ExportAction
 
 
 
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private static Map<String, QTableMetaData> getJoinTableMap(QTableMetaData table)
+   {
+      Map<String, QTableMetaData> joinTableMap = new HashMap<>();
+      for(ExposedJoin exposedJoin : CollectionUtils.nonNullList(table.getExposedJoins()))
+      {
+         joinTableMap.put(exposedJoin.getJoinTable(), QContext.getQInstance().getTable(exposedJoin.getJoinTable()));
+      }
+      return joinTableMap;
+   }
+
+
+
    /*******************************************************************************
     ** Run the report.
     *******************************************************************************/
@@ -149,11 +181,56 @@ public class ExportAction
       // set up a query input //
       //////////////////////////
       QueryAction queryAction = new QueryAction();
-      QueryInput  queryInput  = new QueryInput(exportInput.getInstance());
-      queryInput.setSession(exportInput.getSession());
+      QueryInput  queryInput  = new QueryInput();
       queryInput.setTableName(exportInput.getTableName());
       queryInput.setFilter(exportInput.getQueryFilter());
-      queryInput.setLimit(exportInput.getLimit());
+
+      List<QueryJoin> queryJoins     = new ArrayList<>();
+      Set<String>     addedJoinNames = new HashSet<>();
+      if(CollectionUtils.nullSafeHasContents(exportInput.getFieldNames()))
+      {
+         for(String fieldName : exportInput.getFieldNames())
+         {
+            if(fieldName.contains("."))
+            {
+               String[] parts         = fieldName.split("\\.", 2);
+               String   joinTableName = parts[0];
+               if(!addedJoinNames.contains(joinTableName))
+               {
+                  QueryJoin queryJoin = new QueryJoin(joinTableName).withType(QueryJoin.Type.LEFT).withSelect(true);
+                  queryJoins.add(queryJoin);
+
+                  /////////////////////////////////////////////////////////////////////////////////////////////
+                  // in at least some cases, we need to let the queryJoin know what join-meta-data to use... //
+                  // This code basically mirrors what QFMD is doing right now, so it's better -              //
+                  // but shouldn't all of this just be in JoinsContext?  it does some of this...             //
+                  /////////////////////////////////////////////////////////////////////////////////////////////
+                  QTableMetaData        table               = exportInput.getTable();
+                  Optional<ExposedJoin> exposedJoinOptional = CollectionUtils.nonNullList(table.getExposedJoins()).stream().filter(ej -> ej.getJoinTable().equals(joinTableName)).findFirst();
+                  if(exposedJoinOptional.isEmpty())
+                  {
+                     throw (new QException("Could not find exposed join between base table " + table.getName() + " and requested join table " + joinTableName));
+                  }
+                  ExposedJoin exposedJoin = exposedJoinOptional.get();
+
+                  if(exposedJoin.getJoinPath().size() == 1)
+                  {
+                     queryJoin.setJoinMetaData(QContext.getQInstance().getJoin(exposedJoin.getJoinPath().get(exposedJoin.getJoinPath().size() - 1)));
+                  }
+
+                  addedJoinNames.add(joinTableName);
+               }
+            }
+         }
+      }
+
+      queryInput.setQueryJoins(queryJoins);
+
+      if(queryInput.getFilter() == null)
+      {
+         queryInput.setFilter(new QQueryFilter());
+      }
+      queryInput.getFilter().setLimit(exportInput.getLimit());
       queryInput.setShouldTranslatePossibleValues(true);
 
       /////////////////////////////////////////////////////////////////
@@ -300,24 +377,51 @@ public class ExportAction
     *******************************************************************************/
    private List<QFieldMetaData> getFields(ExportInput exportInput)
    {
+      QTableMetaData              table        = exportInput.getTable();
+      Map<String, QTableMetaData> joinTableMap = getJoinTableMap(table);
+
       List<QFieldMetaData> fieldList;
-      QTableMetaData       table = exportInput.getTable();
       if(exportInput.getFieldNames() != null)
       {
-         fieldList = exportInput.getFieldNames().stream().map(table::getField).toList();
+         fieldList = new ArrayList<>();
+         for(String fieldName : exportInput.getFieldNames())
+         {
+            if(fieldName.contains("."))
+            {
+               String[]       parts     = fieldName.split("\\.", 2);
+               QTableMetaData joinTable = joinTableMap.get(parts[0]);
+               QFieldMetaData field     = joinTable.getField(parts[1]).clone();
+               field.setName(fieldName);
+               field.setLabel(joinTable.getLabel() + ": " + field.getLabel());
+               fieldList.add(field);
+            }
+            else
+            {
+               fieldList.add(table.getField(fieldName));
+            }
+         }
       }
       else
       {
          fieldList = new ArrayList<>(table.getFields().values());
       }
 
-      //////////////////////////////////////////
-      // add fields for possible value labels //
-      //////////////////////////////////////////
       List<QFieldMetaData> returnList = new ArrayList<>();
       for(QFieldMetaData field : fieldList)
       {
+         /////////////////////////////////////////////////////////////////////////////////////////
+         // skip heavy fields.  they aren't fetched, and we generally think we don't want them. //
+         /////////////////////////////////////////////////////////////////////////////////////////
+         if(field.getIsHeavy())
+         {
+            continue;
+         }
+
          returnList.add(field);
+
+         //////////////////////////////////////////
+         // add fields for possible value labels //
+         //////////////////////////////////////////
          if(StringUtils.hasContent(field.getPossibleValueSourceName()))
          {
             returnList.add(new QFieldMetaData(field.getName() + ":possibleValueLabel", QFieldType.STRING).withLabel(field.getLabel() + " Name"));
@@ -350,8 +454,7 @@ public class ExportAction
          if(exportInput.getLimit() == null || exportInput.getLimit() > reportFormat.getMaxRows())
          {
             CountInterface countInterface = backendModule.getCountInterface();
-            CountInput     countInput     = new CountInput(exportInput.getInstance());
-            countInput.setSession(exportInput.getSession());
+            CountInput     countInput     = new CountInput();
             countInput.setTableName(exportInput.getTableName());
             countInput.setFilter(exportInput.getQueryFilter());
             CountOutput countOutput = countInterface.execute(countInput);

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/reporting/FormulaInterpreter.java

@@ -185,7 +185,7 @@ public class FormulaInterpreter
          case "DIVIDE":
          {
             List<BigDecimal> numbers = getNumberArgumentList(args, 2, variableInterpreter);
-            if(numbers.get(1) == null || numbers.get(1).equals(BigDecimal.ZERO))
+            if(numbers.get(1) == null || numbers.get(1).compareTo(BigDecimal.ZERO) == 0)
             {
                return null;
             }
@@ -194,7 +194,7 @@ public class FormulaInterpreter
          case "DIVIDE_SCALE":
          {
             List<BigDecimal> numbers = getNumberArgumentList(args, 3, variableInterpreter);
-            if(numbers.get(1) == null || numbers.get(1).equals(BigDecimal.ZERO))
+            if(numbers.get(1) == null || numbers.get(1).compareTo(BigDecimal.ZERO) == 0)
             {
                return null;
             }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/reporting/GenerateReportAction.java

@@ -45,13 +45,13 @@ import com.kingsrook.qqq.backend.core.exceptions.QException;
 import com.kingsrook.qqq.backend.core.exceptions.QFormulaException;
 import com.kingsrook.qqq.backend.core.exceptions.QReportingException;
 import com.kingsrook.qqq.backend.core.instances.QMetaDataVariableInterpreter;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
 import com.kingsrook.qqq.backend.core.model.actions.processes.RunBackendStepInput;
 import com.kingsrook.qqq.backend.core.model.actions.processes.RunBackendStepOutput;
 import com.kingsrook.qqq.backend.core.model.actions.reporting.ExportInput;
 import com.kingsrook.qqq.backend.core.model.actions.reporting.ReportFormat;
 import com.kingsrook.qqq.backend.core.model.actions.reporting.ReportInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.JoinsContext;
-import com.kingsrook.qqq.backend.core.model.actions.tables.query.QFilterCriteria;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QFilterOrderBy;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QQueryFilter;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryInput;
@@ -65,15 +65,14 @@ import com.kingsrook.qqq.backend.core.model.metadata.reporting.QReportView;
 import com.kingsrook.qqq.backend.core.model.metadata.reporting.ReportType;
 import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
 import com.kingsrook.qqq.backend.core.processes.implementations.etl.streamedwithfrontend.AbstractTransformStep;
+import com.kingsrook.qqq.backend.core.processes.implementations.etl.streamedwithfrontend.BackendStepPostRunInput;
+import com.kingsrook.qqq.backend.core.processes.implementations.etl.streamedwithfrontend.BackendStepPostRunOutput;
 import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
 import com.kingsrook.qqq.backend.core.utils.Pair;
 import com.kingsrook.qqq.backend.core.utils.StringUtils;
-import com.kingsrook.qqq.backend.core.utils.ValueUtils;
 import com.kingsrook.qqq.backend.core.utils.aggregates.AggregatesInterface;
 import com.kingsrook.qqq.backend.core.utils.aggregates.BigDecimalAggregates;
 import com.kingsrook.qqq.backend.core.utils.aggregates.IntegerAggregates;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
 
 
 /*******************************************************************************
@@ -90,7 +89,7 @@ import org.apache.logging.log4j.Logger;
  *******************************************************************************/
 public class GenerateReportAction
 {
-   private static final Logger LOG = LogManager.getLogger(GenerateReportAction.class);
+   private static final QLogger LOG = QLogger.getLogger(GenerateReportAction.class);
 
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////
    // summaryAggregates and varianceAggregates are multi-level maps, ala:                                     //
@@ -216,8 +215,7 @@ public class GenerateReportAction
       QMetaDataVariableInterpreter variableInterpreter = new QMetaDataVariableInterpreter();
       variableInterpreter.addValueMap("input", reportInput.getInputValues());
 
-      ExportInput exportInput = new ExportInput(reportInput.getInstance());
-      exportInput.setSession(reportInput.getSession());
+      ExportInput exportInput = new ExportInput();
       exportInput.setReportFormat(reportFormat);
       exportInput.setFilename(reportInput.getFilename());
       exportInput.setTitleRow(getTitle(reportView, variableInterpreter));
@@ -227,7 +225,7 @@ public class GenerateReportAction
       JoinsContext joinsContext = null;
       if(StringUtils.hasContent(dataSource.getSourceTable()))
       {
-         joinsContext = new JoinsContext(exportInput.getInstance(), dataSource.getSourceTable(), dataSource.getQueryJoins());
+         joinsContext = new JoinsContext(exportInput.getInstance(), dataSource.getSourceTable(), dataSource.getQueryJoins(), dataSource.getQueryFilter());
       }
 
       List<QFieldMetaData> fields = new ArrayList<>();
@@ -277,8 +275,7 @@ public class GenerateReportAction
       {
          transformStep = QCodeLoader.getBackendStep(AbstractTransformStep.class, tableView.getRecordTransformStep());
 
-         transformStepInput = new RunBackendStepInput(reportInput.getInstance());
-         transformStepInput.setSession(reportInput.getSession());
+         transformStepInput = new RunBackendStepInput();
          transformStepInput.setValues(reportInput.getInputValues());
 
          transformStepOutput = new RunBackendStepOutput();
@@ -304,15 +301,14 @@ public class GenerateReportAction
             QQueryFilter queryFilter = dataSource.getQueryFilter() == null ? new QQueryFilter() : dataSource.getQueryFilter().clone();
             setInputValuesInQueryFilter(reportInput, queryFilter);
 
-            QueryInput queryInput = new QueryInput(reportInput.getInstance());
-            queryInput.setSession(reportInput.getSession());
+            QueryInput queryInput = new QueryInput();
             queryInput.setRecordPipe(recordPipe);
             queryInput.setTableName(dataSource.getSourceTable());
             queryInput.setFilter(queryFilter);
             queryInput.setQueryJoins(dataSource.getQueryJoins());
 
             queryInput.setShouldTranslatePossibleValues(true);
-            queryInput.setFieldsToTranslatePossibleValues(setupFieldsToTranslatePossibleValues(reportInput, dataSource, new JoinsContext(reportInput.getInstance(), dataSource.getSourceTable(), dataSource.getQueryJoins())));
+            queryInput.setFieldsToTranslatePossibleValues(setupFieldsToTranslatePossibleValues(reportInput, dataSource, new JoinsContext(reportInput.getInstance(), dataSource.getSourceTable(), dataSource.getQueryJoins(), queryInput.getFilter())));
 
             if(dataSource.getQueryInputCustomizer() != null)
             {
@@ -361,7 +357,7 @@ public class GenerateReportAction
       ////////////////////////////////////////////////
       if(transformStep != null)
       {
-         transformStep.postRun(transformStepInput, transformStepOutput);
+         transformStep.postRun(new BackendStepPostRunInput(transformStepInput), new BackendStepPostRunOutput(transformStepOutput));
       }
    }
 
@@ -416,23 +412,7 @@ public class GenerateReportAction
          return;
       }
 
-      QMetaDataVariableInterpreter variableInterpreter = new QMetaDataVariableInterpreter();
-      variableInterpreter.addValueMap("input", reportInput.getInputValues());
-      for(QFilterCriteria criterion : queryFilter.getCriteria())
-      {
-         if(criterion.getValues() != null)
-         {
-            List<Serializable> newValues = new ArrayList<>();
-
-            for(Serializable value : criterion.getValues())
-            {
-               String       valueAsString    = ValueUtils.getValueAsString(value);
-               Serializable interpretedValue = variableInterpreter.interpretForObject(valueAsString);
-               newValues.add(interpretedValue);
-            }
-            criterion.setValues(newValues);
-         }
-      }
+      queryFilter.interpretValues(reportInput.getInputValues());
    }
 
 
@@ -597,8 +577,7 @@ public class GenerateReportAction
          QTableMetaData    table         = reportInput.getInstance().getTable(dataSource.getSourceTable());
          SummaryOutput     summaryOutput = computeSummaryRowsForView(reportInput, view, table);
 
-         ExportInput exportInput = new ExportInput(reportInput.getInstance());
-         exportInput.setSession(reportInput.getSession());
+         ExportInput exportInput = new ExportInput();
          exportInput.setReportFormat(reportFormat);
          exportInput.setFilename(reportInput.getFilename());
          exportInput.setTitleRow(summaryOutput.titleRow);

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/reporting/JsonExportStreamer.java

@@ -30,14 +30,13 @@ import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import com.kingsrook.qqq.backend.core.exceptions.QReportingException;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
 import com.kingsrook.qqq.backend.core.model.actions.reporting.ExportInput;
 import com.kingsrook.qqq.backend.core.model.data.QRecord;
 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.utils.JsonUtils;
 import com.kingsrook.qqq.backend.core.utils.StringUtils;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
 
 
 /*******************************************************************************
@@ -45,14 +44,14 @@ import org.apache.logging.log4j.Logger;
  *******************************************************************************/
 public class JsonExportStreamer implements ExportStreamerInterface
 {
-   private static final Logger LOG = LogManager.getLogger(JsonExportStreamer.class);
+   private static final QLogger LOG = QLogger.getLogger(JsonExportStreamer.class);
 
    private ExportInput          exportInput;
    private QTableMetaData       table;
    private List<QFieldMetaData> fields;
    private OutputStream         outputStream;
 
-   private boolean needComma = false;
+   private boolean needComma   = false;
    private boolean prettyPrint = true;
 
 

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/reporting/ListOfMapsExportStreamer.java

@@ -27,11 +27,10 @@ import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import com.kingsrook.qqq.backend.core.exceptions.QReportingException;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
 import com.kingsrook.qqq.backend.core.model.actions.reporting.ExportInput;
 import com.kingsrook.qqq.backend.core.model.data.QRecord;
 import com.kingsrook.qqq.backend.core.model.metadata.fields.QFieldMetaData;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
 
 
 /*******************************************************************************
@@ -41,7 +40,7 @@ import org.apache.logging.log4j.Logger;
  *******************************************************************************/
 public class ListOfMapsExportStreamer implements ExportStreamerInterface
 {
-   private static final Logger LOG = LogManager.getLogger(ListOfMapsExportStreamer.class);
+   private static final QLogger LOG = QLogger.getLogger(ListOfMapsExportStreamer.class);
 
    private ExportInput          exportInput;
    private List<QFieldMetaData> fields;

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/reporting/RecordPipe.java

@@ -26,11 +26,11 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.ArrayBlockingQueue;
 import java.util.concurrent.TimeUnit;
-import java.util.function.Consumer;
+import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
 import com.kingsrook.qqq.backend.core.model.data.QRecord;
 import com.kingsrook.qqq.backend.core.utils.SleepUtils;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
+import com.kingsrook.qqq.backend.core.utils.lambdas.UnsafeConsumer;
 
 
 /*******************************************************************************
@@ -39,7 +39,7 @@ import org.apache.logging.log4j.Logger;
  *******************************************************************************/
 public class RecordPipe
 {
-   private static final Logger LOG = LogManager.getLogger(RecordPipe.class);
+   private static final QLogger LOG = QLogger.getLogger(RecordPipe.class);
 
    private static final long BLOCKING_SLEEP_MILLIS = 100;
    private static final long MAX_SLEEP_LOOP_MILLIS = 300_000; // 5 minutes
@@ -48,7 +48,7 @@ public class RecordPipe
 
    private boolean isTerminated = false;
 
-   private Consumer<List<QRecord>> postRecordActions = null;
+   private UnsafeConsumer<List<QRecord>, QException> postRecordActions = null;
 
    /////////////////////////////////////
    // See usage below for explanation //
@@ -94,7 +94,7 @@ public class RecordPipe
    /*******************************************************************************
     ** Add a record to the pipe.  Will block if the pipe is full.  Will noop if pipe is terminated.
     *******************************************************************************/
-   public void addRecord(QRecord record)
+   public void addRecord(QRecord record) throws QException
    {
       if(isTerminated)
       {
@@ -110,7 +110,7 @@ public class RecordPipe
          // (which we'll create as a field in this class, to avoid always re-constructing) //
          ////////////////////////////////////////////////////////////////////////////////////
          singleRecordListForPostRecordActions.add(record);
-         postRecordActions.accept(singleRecordListForPostRecordActions);
+         postRecordActions.run(singleRecordListForPostRecordActions);
          record = singleRecordListForPostRecordActions.remove(0);
       }
 
@@ -153,11 +153,11 @@ public class RecordPipe
    /*******************************************************************************
     ** Add a list of records to the pipe.  Will block if the pipe is full.  Will noop if pipe is terminated.
     *******************************************************************************/
-   public void addRecords(List<QRecord> records)
+   public void addRecords(List<QRecord> records) throws QException
    {
       if(postRecordActions != null)
       {
-         postRecordActions.accept(records);
+         postRecordActions.run(records);
       }
 
       //////////////////////////////////////////////////////////////////////////////////////////////////
@@ -208,7 +208,7 @@ public class RecordPipe
    /*******************************************************************************
     **
     *******************************************************************************/
-   public void setPostRecordActions(Consumer<List<QRecord>> postRecordActions)
+   public void setPostRecordActions(UnsafeConsumer<List<QRecord>, QException> postRecordActions)
    {
       this.postRecordActions = postRecordActions;
    }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/reporting/RecordPipeBufferedWrapper.java

@@ -0,0 +1,79 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2022.  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.reporting;
+
+
+import java.util.List;
+import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.model.data.QRecord;
+
+
+/*******************************************************************************
+ ** Subclass of BufferedRecordPipe, which ultimately sends records down to an
+ ** original RecordPipe.
+ **
+ ** Meant to be used where: someone passed in a RecordPipe (so they have a reference
+ ** to it, and they are waiting to read from it), but the producer knows that
+ ** it will be better to buffer the records, so they want to use a buffered pipe
+ ** (but they still need the records to end up in the original pipe - thus -
+ ** it gets wrapped by an object of this class).
+ *******************************************************************************/
+public class RecordPipeBufferedWrapper extends BufferedRecordPipe
+{
+   private RecordPipe wrappedPipe;
+
+
+
+   /*******************************************************************************
+    ** Constructor - uses default buffer size
+    **
+    *******************************************************************************/
+   public RecordPipeBufferedWrapper(RecordPipe wrappedPipe)
+   {
+      this.wrappedPipe = wrappedPipe;
+   }
+
+
+
+   /*******************************************************************************
+    ** Constructor - customize buffer size.
+    **
+    *******************************************************************************/
+   public RecordPipeBufferedWrapper(Integer bufferSize, RecordPipe wrappedPipe)
+   {
+      super(bufferSize);
+      this.wrappedPipe = wrappedPipe;
+   }
+
+
+
+   /*******************************************************************************
+    ** when it's time to actually add records into the pipe, actually add them
+    ** into the wrapped pipe!
+    *******************************************************************************/
+   @Override
+   public void addRecords(List<QRecord> records) throws QException
+   {
+      wrappedPipe.addRecords(records);
+   }
+
+}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/scripts/AssociatedScriptContextPrimerInterface.java

@@ -0,0 +1,41 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2022.  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.scripts;
+
+
+import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.model.actions.scripts.ExecuteCodeInput;
+import com.kingsrook.qqq.backend.core.model.scripts.ScriptRevision;
+
+
+/*******************************************************************************
+ **
+ *******************************************************************************/
+public interface AssociatedScriptContextPrimerInterface
+{
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   void primeContext(ExecuteCodeInput executeCodeInput, ScriptRevision scriptRevision) throws QException;
+
+}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/scripts/ExecuteCodeAction.java

@@ -23,15 +23,36 @@ package com.kingsrook.qqq.backend.core.actions.scripts;
 
 
 import java.io.Serializable;
+import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import com.kingsrook.qqq.backend.core.actions.scripts.logging.Log4jCodeExecutionLogger;
 import com.kingsrook.qqq.backend.core.actions.scripts.logging.QCodeExecutionLoggerInterface;
+import com.kingsrook.qqq.backend.core.actions.scripts.logging.ScriptExecutionLoggerInterface;
+import com.kingsrook.qqq.backend.core.actions.scripts.logging.StoreScriptLogAndScriptLogLineExecutionLogger;
+import com.kingsrook.qqq.backend.core.actions.tables.QueryAction;
+import com.kingsrook.qqq.backend.core.context.QContext;
 import com.kingsrook.qqq.backend.core.exceptions.QCodeException;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
+import com.kingsrook.qqq.backend.core.model.actions.scripts.AbstractRunScriptInput;
 import com.kingsrook.qqq.backend.core.model.actions.scripts.ExecuteCodeInput;
 import com.kingsrook.qqq.backend.core.model.actions.scripts.ExecuteCodeOutput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QCriteriaOperator;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QFilterCriteria;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QQueryFilter;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryOutput;
+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.code.QCodeType;
+import com.kingsrook.qqq.backend.core.model.scripts.ScriptRevision;
+import com.kingsrook.qqq.backend.core.model.scripts.ScriptRevisionFile;
+import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
+import com.kingsrook.qqq.backend.core.utils.ObjectUtils;
+import com.kingsrook.qqq.backend.core.utils.StringUtils;
 
 
 /*******************************************************************************
@@ -49,6 +70,9 @@ import com.kingsrook.qqq.backend.core.model.metadata.code.QCodeReference;
  *******************************************************************************/
 public class ExecuteCodeAction
 {
+   private static final QLogger LOG = QLogger.getLogger(ExecuteCodeAction.class);
+
+
 
    /*******************************************************************************
     **
@@ -68,10 +92,10 @@ public class ExecuteCodeAction
       try
       {
          String languageExecutor = switch(codeReference.getCodeType())
-            {
-               case JAVA -> "com.kingsrook.qqq.backend.core.actions.scripts.QJavaExecutor";
-               case JAVA_SCRIPT -> "com.kingsrook.qqq.languages.javascript.QJavaScriptExecutor";
-            };
+         {
+            case JAVA -> "com.kingsrook.qqq.backend.core.actions.scripts.QJavaExecutor";
+            case JAVA_SCRIPT -> "com.kingsrook.qqq.languages.javascript.QJavaScriptExecutor";
+         };
 
          @SuppressWarnings("unchecked")
          Class<? extends QCodeExecutor> executorClass = (Class<? extends QCodeExecutor>) Class.forName(languageExecutor);
@@ -90,6 +114,22 @@ public class ExecuteCodeAction
             context.putAll(input.getInput());
          }
 
+         //////////////////////////////////////////
+         // safely always set the deploymentMode //
+         //////////////////////////////////////////
+         context.put("deploymentMode", ObjectUtils.tryAndRequireNonNullElse(() -> QContext.getQInstance().getDeploymentMode(), null));
+
+         /////////////////////////////////////////////////////////////////////////////////
+         // set the qCodeExecutor into any context objects which are QCodeExecutorAware //
+         /////////////////////////////////////////////////////////////////////////////////
+         for(Serializable value : context.values())
+         {
+            if(value instanceof QCodeExecutorAware qCodeExecutorAware)
+            {
+               qCodeExecutorAware.setQCodeExecutor(qCodeExecutor);
+            }
+         }
+
          Serializable codeOutput = qCodeExecutor.execute(codeReference, context, executionLogger);
          output.setOutput(codeOutput);
          executionLogger.acceptExecutionEnd(codeOutput);
@@ -108,6 +148,156 @@ public class ExecuteCodeAction
 
 
 
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public static ExecuteCodeInput setupExecuteCodeInput(AbstractRunScriptInput<?> input, ScriptRevision scriptRevision) throws QException
+   {
+      return setupExecuteCodeInput(input, scriptRevision, null);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public static ExecuteCodeInput setupExecuteCodeInput(AbstractRunScriptInput<?> input, ScriptRevision scriptRevision, String fileName) throws QException
+   {
+      ExecuteCodeInput executeCodeInput = new ExecuteCodeInput();
+      executeCodeInput.setInput(new HashMap<>(Objects.requireNonNullElseGet(input.getInputValues(), HashMap::new)));
+      executeCodeInput.setContext(new HashMap<>());
+
+      Map<String, Serializable> context = executeCodeInput.getContext();
+      if(input.getOutputObject() != null)
+      {
+         context.put("output", input.getOutputObject());
+      }
+
+      if(input.getScriptUtils() != null)
+      {
+         context.put("scriptUtils", input.getScriptUtils());
+      }
+
+      if(CollectionUtils.nullSafeIsEmpty(scriptRevision.getFiles()))
+      {
+         QueryInput queryInput = new QueryInput();
+         queryInput.setTableName(ScriptRevisionFile.TABLE_NAME);
+         queryInput.setFilter(new QQueryFilter(new QFilterCriteria("scriptRevisionId", QCriteriaOperator.EQUALS, scriptRevision.getId())));
+         QueryOutput queryOutput = new QueryAction().execute(queryInput);
+
+         scriptRevision.setFiles(new ArrayList<>());
+         for(QRecord record : queryOutput.getRecords())
+         {
+            scriptRevision.getFiles().add(new ScriptRevisionFile(record));
+         }
+      }
+
+      List<ScriptRevisionFile> files = scriptRevision.getFiles();
+      if(files == null || files.isEmpty())
+      {
+         throw (new QException("Script Revision " + scriptRevision.getId() + " had more than 1 associated ScriptRevisionFile (and the name to use was not specified)."));
+      }
+      else
+      {
+         String contents = null;
+         if(fileName == null || files.size() == 1)
+         {
+            contents = files.get(0).getContents();
+         }
+         else
+         {
+            for(ScriptRevisionFile file : files)
+            {
+               if(file.getFileName().equals(fileName))
+               {
+                  contents = file.getContents();
+               }
+            }
+            if(contents == null)
+            {
+               throw (new QException("Could not find file named " + fileName + " for Script Revision " + scriptRevision.getId()));
+            }
+         }
+
+         executeCodeInput.setCodeReference(new QCodeReference().withInlineCode(contents).withCodeType(QCodeType.JAVA_SCRIPT)); // todo - code type as attribute of script!!
+      }
+
+      ExecuteCodeAction.addApiUtilityToContext(context, scriptRevision);
+      context.put("qqq", new QqqScriptUtils());
+      ExecuteCodeAction.setExecutionLoggerInExecuteCodeInput(input, scriptRevision, executeCodeInput);
+
+      return (executeCodeInput);
+   }
+
+
+
+   /*******************************************************************************
+    ** Try to (dynamically) load the ApiScriptUtils object from the api middleware
+    ** module -- in case the runtime doesn't have that module deployed (e.g, not in
+    ** the project pom).
+    *******************************************************************************/
+   public static void addApiUtilityToContext(Map<String, Serializable> context, ScriptRevision scriptRevision)
+   {
+      addApiUtilityToContext(context, scriptRevision.getApiName(), scriptRevision.getApiVersion());
+   }
+
+
+
+   /*******************************************************************************
+    ** Try to (dynamically) load the ApiScriptUtils object from the api middleware
+    ** module -- in case the runtime doesn't have that module deployed (e.g, not in
+    ** the project pom).
+    *******************************************************************************/
+   public static void addApiUtilityToContext(Map<String, Serializable> context, String apiName, String apiVersion)
+   {
+      if(!StringUtils.hasContent(apiName) || !StringUtils.hasContent(apiVersion))
+      {
+         return;
+      }
+
+      try
+      {
+         Class<?> apiScriptUtilsClass  = Class.forName("com.kingsrook.qqq.api.utils.ApiScriptUtils");
+         Object   apiScriptUtilsObject = apiScriptUtilsClass.getConstructor(String.class, String.class).newInstance(apiName, apiVersion);
+         context.put("api", (Serializable) apiScriptUtilsObject);
+      }
+      catch(ClassNotFoundException e)
+      {
+         /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+         // this is the only exception we're kinda expecting here - so catch for it specifically, and just log.trace - others, warn //
+         /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+         LOG.trace("Couldn't load ApiScriptUtils class - qqq-middleware-api not on the classpath?");
+      }
+      catch(Exception e)
+      {
+         LOG.warn("Error adding api utility to script context", e);
+      }
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private static void setExecutionLoggerInExecuteCodeInput(AbstractRunScriptInput<?> input, ScriptRevision scriptRevision, ExecuteCodeInput executeCodeInput)
+   {
+      /////////////////////////////////////////////////////////////////////////////////////////////////
+      // let caller supply a logger, or by default use StoreScriptLogAndScriptLogLineExecutionLogger //
+      /////////////////////////////////////////////////////////////////////////////////////////////////
+      QCodeExecutionLoggerInterface executionLogger = Objects.requireNonNullElseGet(input.getLogger(), () -> new StoreScriptLogAndScriptLogLineExecutionLogger(scriptRevision.getScriptId(), scriptRevision.getId()));
+      executeCodeInput.setExecutionLogger(executionLogger);
+      if(executionLogger instanceof ScriptExecutionLoggerInterface scriptExecutionLoggerInterface)
+      {
+         ////////////////////////////////////////////////////////////////////////////////////////////////////
+         // if logger is aware of scripts (as opposed to a generic CodeExecution logger), give it the ids. //
+         ////////////////////////////////////////////////////////////////////////////////////////////////////
+         scriptExecutionLoggerInterface.setScriptId(scriptRevision.getScriptId());
+         scriptExecutionLoggerInterface.setScriptRevisionId(scriptRevision.getId());
+      }
+   }
+
+
+
    /*******************************************************************************
     **
     *******************************************************************************/

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/scripts/QCodeExecutor.java

@@ -41,4 +41,24 @@ public interface QCodeExecutor
     *******************************************************************************/
    Serializable execute(QCodeReference codeReference, Map<String, Serializable> inputContext, QCodeExecutionLoggerInterface executionLogger) throws QCodeException;
 
+   /*******************************************************************************
+    ** Process an object from the script's language/runtime into a (more) native java object.
+    ** e.g., a Nashorn ScriptObjectMirror will end up as a "primitive", or a List or Map of such
+    **
+    *******************************************************************************/
+   default Object convertObjectToJava(Object object) throws QCodeException
+   {
+      return (object);
+   }
+
+   /*******************************************************************************
+    ** Convert a native java object into one for the script's language/runtime.
+    ** e.g., a java Instant to a Nashorn Date
+    **
+    *******************************************************************************/
+   default Object convertJavaObject(Object object, Object requestedTypeHint) throws QCodeException
+   {
+      return (object);
+   }
+
 }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/scripts/QCodeExecutorAware.java

@@ -0,0 +1,36 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2023.  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.scripts;
+
+
+/*******************************************************************************
+ ** Interface for classes that can accept a QCodeExecutor object via a setter.
+ *******************************************************************************/
+public interface QCodeExecutorAware
+{
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   void setQCodeExecutor(QCodeExecutor qCodeExecutor);
+
+}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/scripts/QqqScriptUtils.java

@@ -0,0 +1,245 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2023.  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.scripts;
+
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.List;
+import com.kingsrook.qqq.backend.core.actions.permissions.PermissionsHelper;
+import com.kingsrook.qqq.backend.core.actions.permissions.TablePermissionSubType;
+import com.kingsrook.qqq.backend.core.actions.tables.DeleteAction;
+import com.kingsrook.qqq.backend.core.actions.tables.InsertAction;
+import com.kingsrook.qqq.backend.core.actions.tables.QueryAction;
+import com.kingsrook.qqq.backend.core.actions.tables.UpdateAction;
+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.delete.DeleteInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.insert.InsertInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QFilterCriteria;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QFilterOrderBy;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QQueryFilter;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.update.UpdateInput;
+import com.kingsrook.qqq.backend.core.model.data.QRecord;
+import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
+
+
+/*******************************************************************************
+ ** Object made available to scripts for access to qqq api (e.g., query, insert,
+ ** etc, plus object constructors).
+ **
+ ** Before scripts knew about the API, this class made sense and was used.
+ ** But, when scripts gained knowledge of the API, then it felt like this class could
+ ** be deleted... but, what about, a QQQ deployment without the API module...
+ ** In that case, we might still want this class... think about it.
+ **
+ ** And/Or - it turns out - sometimes using QQQ directly is "better" (?) than using
+ ** an api - so - this object may be available for other use cases (e.g., getting
+ ** a record's backendDetails (e.g., for full json from a source backend api)).
+ *******************************************************************************/
+public class QqqScriptUtils implements Serializable
+{
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public QueryInput newQueryInput()
+   {
+      return (new QueryInput());
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public QQueryFilter newQueryFilter()
+   {
+      return (new QQueryFilter());
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public QFilterCriteria newFilterCriteria()
+   {
+      return (new QFilterCriteria());
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public QFilterOrderBy newFilterOrderBy()
+   {
+      return (new QFilterOrderBy());
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public QRecord newRecord()
+   {
+      return (new QRecord());
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public List<QRecord> query(String tableName, QQueryFilter filter) throws QException
+   {
+      QueryInput queryInput = new QueryInput();
+      queryInput.setTableName(tableName);
+      queryInput.setFilter(filter);
+      PermissionsHelper.checkTablePermissionThrowing(queryInput, TablePermissionSubType.READ);
+      return (new QueryAction().execute(queryInput).getRecords());
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public List<QRecord> query(QueryInput queryInput) throws QException
+   {
+      PermissionsHelper.checkTablePermissionThrowing(queryInput, TablePermissionSubType.READ);
+      return (new QueryAction().execute(queryInput).getRecords());
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public void insert(String tableName, QRecord record) throws QException
+   {
+      insert(tableName, List.of(record));
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public void insert(String tableName, List<QRecord> recordList) throws QException
+   {
+      InsertInput insertInput = new InsertInput();
+      insertInput.setTableName(tableName);
+      insertInput.setRecords(recordList);
+      PermissionsHelper.checkTablePermissionThrowing(insertInput, TablePermissionSubType.INSERT);
+      new InsertAction().execute(insertInput);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public void update(String tableName, QRecord record) throws QException
+   {
+      update(tableName, List.of(record));
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public void update(String tableName, List<QRecord> recordList) throws QException
+   {
+      UpdateInput updateInput = new UpdateInput();
+      updateInput.setTableName(tableName);
+      updateInput.setRecords(recordList);
+      PermissionsHelper.checkTablePermissionThrowing(updateInput, TablePermissionSubType.EDIT);
+      new UpdateAction().execute(updateInput);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public void delete(String tableName, Serializable primaryKey) throws QException
+   {
+      delete(tableName, List.of(primaryKey));
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public void delete(String tableName, QRecord record) throws QException
+   {
+      delete(tableName, List.of(record));
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public void delete(String tableName, List<?> recordOrPrimaryKeyList) throws QException
+   {
+      QTableMetaData table       = QContext.getQInstance().getTable(tableName);
+      DeleteInput    deleteInput = new DeleteInput();
+      deleteInput.setTableName(tableName);
+      List<Serializable> primaryKeyList = new ArrayList<>();
+      for(Object o : recordOrPrimaryKeyList)
+      {
+         if(o instanceof QRecord qRecord)
+         {
+            primaryKeyList.add(qRecord.getValue(table.getPrimaryKeyField()));
+         }
+         else
+         {
+            primaryKeyList.add((Serializable) o);
+         }
+      }
+      deleteInput.setPrimaryKeys(primaryKeyList);
+      PermissionsHelper.checkTablePermissionThrowing(deleteInput, TablePermissionSubType.DELETE);
+      new DeleteAction().execute(deleteInput);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public void delete(String tableName, QQueryFilter filter) throws QException
+   {
+      DeleteInput deleteInput = new DeleteInput();
+      deleteInput.setTableName(tableName);
+      deleteInput.setQueryFilter(filter);
+      PermissionsHelper.checkTablePermissionThrowing(deleteInput, TablePermissionSubType.DELETE);
+      new DeleteAction().execute(deleteInput);
+   }
+
+}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/scripts/RecordScriptTestInterface.java

@@ -0,0 +1,159 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2023.  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.scripts;
+
+
+import java.io.Serializable;
+import java.util.Collections;
+import java.util.List;
+import com.kingsrook.qqq.backend.core.actions.scripts.logging.BuildScriptLogAndScriptLogLineExecutionLogger;
+import com.kingsrook.qqq.backend.core.actions.tables.GetAction;
+import com.kingsrook.qqq.backend.core.actions.tables.QueryAction;
+import com.kingsrook.qqq.backend.core.context.QContext;
+import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.model.actions.scripts.ExecuteCodeInput;
+import com.kingsrook.qqq.backend.core.model.actions.scripts.RunAdHocRecordScriptInput;
+import com.kingsrook.qqq.backend.core.model.actions.scripts.RunAdHocRecordScriptOutput;
+import com.kingsrook.qqq.backend.core.model.actions.scripts.TestScriptInput;
+import com.kingsrook.qqq.backend.core.model.actions.scripts.TestScriptOutput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.get.GetInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QCriteriaOperator;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QFilterCriteria;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QQueryFilter;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryOutput;
+import com.kingsrook.qqq.backend.core.model.data.QRecord;
+import com.kingsrook.qqq.backend.core.model.metadata.code.AdHocScriptCodeReference;
+import com.kingsrook.qqq.backend.core.model.metadata.fields.QFieldMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.fields.QFieldType;
+import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
+import com.kingsrook.qqq.backend.core.model.scripts.Script;
+import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
+import com.kingsrook.qqq.backend.core.utils.StringUtils;
+import com.kingsrook.qqq.backend.core.utils.ValueUtils;
+
+
+/*******************************************************************************
+ **
+ *******************************************************************************/
+public class RecordScriptTestInterface implements TestScriptActionInterface
+{
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Override
+   public void setupTestScriptInput(TestScriptInput testScriptInput, ExecuteCodeInput executeCodeInput) throws QException
+   {
+
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Override
+   public void execute(TestScriptInput input, TestScriptOutput output) throws QException
+   {
+      try
+      {
+         Serializable scriptId = input.getInputValues().get("scriptId");
+         QRecord      script   = new GetAction().executeForRecord(new GetInput(Script.TABLE_NAME).withPrimaryKey(scriptId));
+
+         //////////////////////////////////////////////
+         // look up the records being tested against //
+         //////////////////////////////////////////////
+         String         tableName = script.getValueString("tableName");
+         QTableMetaData table     = QContext.getQInstance().getTable(tableName);
+         if(table == null)
+         {
+            throw (new QException("Could not find table [" + tableName + "] for script"));
+         }
+
+         String recordPrimaryKeyList = ValueUtils.getValueAsString(input.getInputValues().get("recordPrimaryKeyList"));
+         if(!StringUtils.hasContent(recordPrimaryKeyList))
+         {
+            throw (new QException("Record primary key list was not given."));
+         }
+
+         QueryOutput queryOutput = new QueryAction().execute(new QueryInput(tableName)
+            .withFilter(new QQueryFilter(new QFilterCriteria(table.getPrimaryKeyField(), QCriteriaOperator.IN, recordPrimaryKeyList.split(","))))
+            .withIncludeAssociations(true));
+         if(CollectionUtils.nullSafeIsEmpty(queryOutput.getRecords()))
+         {
+            throw (new QException("No records were found by the given primary keys."));
+         }
+
+         /////////////////////////////
+         // set up & run the action //
+         /////////////////////////////
+         RunAdHocRecordScriptInput runAdHocRecordScriptInput = new RunAdHocRecordScriptInput();
+         runAdHocRecordScriptInput.setRecordList(queryOutput.getRecords());
+
+         BuildScriptLogAndScriptLogLineExecutionLogger executionLogger = new BuildScriptLogAndScriptLogLineExecutionLogger(null, null);
+         runAdHocRecordScriptInput.setLogger(executionLogger);
+
+         runAdHocRecordScriptInput.setTableName(tableName);
+         runAdHocRecordScriptInput.setCodeReference((AdHocScriptCodeReference) input.getCodeReference());
+         RunAdHocRecordScriptOutput runAdHocRecordScriptOutput = new RunAdHocRecordScriptOutput();
+         new RunAdHocRecordScriptAction().run(runAdHocRecordScriptInput, runAdHocRecordScriptOutput);
+
+         /////////////////////////////////
+         // send outputs back to caller //
+         /////////////////////////////////
+         output.setScriptLog(executionLogger.getScriptLog());
+         output.setScriptLogLines(executionLogger.getScriptLogLines());
+         if(runAdHocRecordScriptOutput.getException().isPresent())
+         {
+            output.setException(runAdHocRecordScriptOutput.getException().get());
+         }
+      }
+      catch(QException e)
+      {
+         output.setException(e);
+      }
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Override
+   public List<QFieldMetaData> getTestInputFields()
+   {
+      return (List.of(new QFieldMetaData("recordPrimaryKeyList", QFieldType.STRING).withLabel("Record Primary Key List")));
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Override
+   public List<QFieldMetaData> getTestOutputFields()
+   {
+      return (Collections.emptyList());
+   }
+
+}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/scripts/RunAdHocRecordScriptAction.java

@@ -0,0 +1,220 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2022.  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.scripts;
+
+
+import java.io.Serializable;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import com.kingsrook.qqq.backend.core.actions.ActionHelper;
+import com.kingsrook.qqq.backend.core.actions.tables.GetAction;
+import com.kingsrook.qqq.backend.core.actions.tables.QueryAction;
+import com.kingsrook.qqq.backend.core.context.QContext;
+import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
+import com.kingsrook.qqq.backend.core.model.actions.scripts.ExecuteCodeInput;
+import com.kingsrook.qqq.backend.core.model.actions.scripts.ExecuteCodeOutput;
+import com.kingsrook.qqq.backend.core.model.actions.scripts.RunAdHocRecordScriptInput;
+import com.kingsrook.qqq.backend.core.model.actions.scripts.RunAdHocRecordScriptOutput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.get.GetInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.get.GetOutput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QCriteriaOperator;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QFilterCriteria;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QQueryFilter;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryJoin;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryOutput;
+import com.kingsrook.qqq.backend.core.model.metadata.code.AdHocScriptCodeReference;
+import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
+import com.kingsrook.qqq.backend.core.model.scripts.Script;
+import com.kingsrook.qqq.backend.core.model.scripts.ScriptRevision;
+import com.kingsrook.qqq.backend.core.model.scripts.ScriptsMetaDataProvider;
+import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
+
+
+/*******************************************************************************
+ **
+ *******************************************************************************/
+public class RunAdHocRecordScriptAction
+{
+   private static final QLogger LOG = QLogger.getLogger(RunAdHocRecordScriptAction.class);
+
+   private Map<Integer, ScriptRevision> scriptRevisionCacheByScriptRevisionId = new HashMap<>();
+   private Map<Integer, ScriptRevision> scriptRevisionCacheByScriptId         = new HashMap<>();
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public void run(RunAdHocRecordScriptInput input, RunAdHocRecordScriptOutput output) throws QException
+   {
+      try
+      {
+         ActionHelper.validateSession(input);
+
+         /////////////////////////
+         // figure out the code //
+         /////////////////////////
+         ScriptRevision scriptRevision = getScriptRevision(input);
+         if(scriptRevision == null)
+         {
+            throw (new QException("Script revision was not found."));
+         }
+
+         ////////////////////////////
+         // figure out the records //
+         ////////////////////////////
+         QTableMetaData table = QContext.getQInstance().getTable(input.getTableName());
+         if(CollectionUtils.nullSafeIsEmpty(input.getRecordList()))
+         {
+            QueryInput queryInput = new QueryInput();
+            queryInput.setTableName(input.getTableName());
+            queryInput.setFilter(new QQueryFilter(new QFilterCriteria(table.getPrimaryKeyField(), QCriteriaOperator.IN, input.getRecordPrimaryKeyList())));
+            queryInput.setIncludeAssociations(true);
+            QueryOutput queryOutput = new QueryAction().execute(queryInput);
+            input.setRecordList(queryOutput.getRecords());
+         }
+
+         if(CollectionUtils.nullSafeIsEmpty(input.getRecordList()))
+         {
+            ////////////////////////////////////////
+            // just return if nothing found?  idk //
+            ////////////////////////////////////////
+            LOG.info("No records supplied as input (or found via primary keys); exiting with noop");
+            return;
+         }
+
+         /////////////
+         // run it! //
+         /////////////
+         ExecuteCodeInput executeCodeInput = ExecuteCodeAction.setupExecuteCodeInput(input, scriptRevision);
+         executeCodeInput.getInput().put("records", getRecordsForScript(input, scriptRevision));
+
+         ExecuteCodeOutput executeCodeOutput = new ExecuteCodeOutput();
+         new ExecuteCodeAction().run(executeCodeInput, executeCodeOutput);
+
+         output.setOutput(executeCodeOutput.getOutput());
+         output.setLogger(executeCodeInput.getExecutionLogger());
+      }
+      catch(Exception e)
+      {
+         output.setException(Optional.of(e));
+      }
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private static ArrayList<? extends Serializable> getRecordsForScript(RunAdHocRecordScriptInput input, ScriptRevision scriptRevision)
+   {
+      try
+      {
+         Class<?> apiScriptUtilsClass        = Class.forName("com.kingsrook.qqq.api.utils.ApiScriptUtils");
+         Method   qRecordListToApiRecordList = apiScriptUtilsClass.getMethod("qRecordListToApiRecordList", List.class, String.class, String.class, String.class);
+         Object   apiRecordList              = qRecordListToApiRecordList.invoke(null, input.getRecordList(), input.getTableName(), scriptRevision.getApiName(), scriptRevision.getApiVersion());
+
+         // noinspection unchecked
+         return (ArrayList<? extends Serializable>) apiRecordList;
+      }
+      catch(ClassNotFoundException e)
+      {
+         /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+         // this is the only exception we're kinda expecting here - so catch for it specifically, and just log.trace - others, warn //
+         /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+         LOG.trace("Couldn't load ApiScriptUtils class - qqq-middleware-api not on the classpath?");
+      }
+      catch(Exception e)
+      {
+         LOG.warn("Error converting QRecord list to api record list", e);
+      }
+
+      return (new ArrayList<>(input.getRecordList()));
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private ScriptRevision getScriptRevision(RunAdHocRecordScriptInput input) throws QException
+   {
+      AdHocScriptCodeReference codeReference = input.getCodeReference();
+      if(codeReference.getScriptRevisionRecord() != null)
+      {
+         return (new ScriptRevision(codeReference.getScriptRevisionRecord()));
+      }
+
+      if(codeReference.getScriptRevisionId() != null)
+      {
+         if(!scriptRevisionCacheByScriptRevisionId.containsKey(codeReference.getScriptRevisionId()))
+         {
+            GetInput getInput = new GetInput();
+            getInput.setTableName(ScriptRevision.TABLE_NAME);
+            getInput.setPrimaryKey(codeReference.getScriptRevisionId());
+            GetOutput getOutput = new GetAction().execute(getInput);
+            if(getOutput.getRecord() != null)
+            {
+               scriptRevisionCacheByScriptRevisionId.put(codeReference.getScriptRevisionId(), new ScriptRevision(getOutput.getRecord()));
+            }
+            else
+            {
+               scriptRevisionCacheByScriptRevisionId.put(codeReference.getScriptRevisionId(), null);
+            }
+         }
+
+         return (scriptRevisionCacheByScriptRevisionId.get(codeReference.getScriptRevisionId()));
+      }
+
+      if(codeReference.getScriptId() != null)
+      {
+         if(!scriptRevisionCacheByScriptId.containsKey(codeReference.getScriptId()))
+         {
+            QueryInput queryInput = new QueryInput();
+            queryInput.setTableName(ScriptRevision.TABLE_NAME);
+            queryInput.setFilter(new QQueryFilter(new QFilterCriteria("script.id", QCriteriaOperator.EQUALS, codeReference.getScriptId())));
+            queryInput.withQueryJoin(new QueryJoin(Script.TABLE_NAME).withBaseTableOrAlias(ScriptRevision.TABLE_NAME).withJoinMetaData(QContext.getQInstance().getJoin(ScriptsMetaDataProvider.CURRENT_SCRIPT_REVISION_JOIN_NAME)));
+            QueryOutput queryOutput = new QueryAction().execute(queryInput);
+
+            if(CollectionUtils.nullSafeHasContents(queryOutput.getRecords()))
+            {
+               scriptRevisionCacheByScriptId.put(codeReference.getScriptId(), new ScriptRevision(queryOutput.getRecords().get(0)));
+            }
+            else
+            {
+               scriptRevisionCacheByScriptId.put(codeReference.getScriptId(), null);
+            }
+         }
+
+         return (scriptRevisionCacheByScriptId.get(codeReference.getScriptId()));
+      }
+
+      throw (new QException("Code reference did not contain a scriptRevision, scriptRevisionId, or scriptId"));
+   }
+
+}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/scripts/RunAssociatedScriptAction.java

@@ -24,8 +24,8 @@ package com.kingsrook.qqq.backend.core.actions.scripts;
 
 import java.io.Serializable;
 import java.util.HashMap;
+import java.util.Map;
 import com.kingsrook.qqq.backend.core.actions.ActionHelper;
-import com.kingsrook.qqq.backend.core.actions.scripts.logging.StoreScriptLogAndScriptLogLineExecutionLogger;
 import com.kingsrook.qqq.backend.core.actions.tables.GetAction;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
 import com.kingsrook.qqq.backend.core.exceptions.QNotFoundException;
@@ -35,8 +35,7 @@ import com.kingsrook.qqq.backend.core.model.actions.scripts.RunAssociatedScriptI
 import com.kingsrook.qqq.backend.core.model.actions.scripts.RunAssociatedScriptOutput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.get.GetInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.get.GetOutput;
-import com.kingsrook.qqq.backend.core.model.metadata.code.QCodeReference;
-import com.kingsrook.qqq.backend.core.model.metadata.code.QCodeType;
+import com.kingsrook.qqq.backend.core.model.metadata.code.AssociatedScriptCodeReference;
 import com.kingsrook.qqq.backend.core.model.scripts.Script;
 import com.kingsrook.qqq.backend.core.model.scripts.ScriptRevision;
 
@@ -46,6 +45,9 @@ import com.kingsrook.qqq.backend.core.model.scripts.ScriptRevision;
  *******************************************************************************/
 public class RunAssociatedScriptAction
 {
+   private Map<AssociatedScriptCodeReference, ScriptRevision> scriptRevisionCache = new HashMap<>();
+
+
 
    /*******************************************************************************
     **
@@ -54,32 +56,14 @@ public class RunAssociatedScriptAction
    {
       ActionHelper.validateSession(input);
 
-      Serializable scriptId = getScriptId(input);
-      if(scriptId == null)
+      ScriptRevision   scriptRevision   = getScriptRevision(input);
+      ExecuteCodeInput executeCodeInput = ExecuteCodeAction.setupExecuteCodeInput(input, scriptRevision);
+
+      if(input.getAssociatedScriptContextPrimerInterface() != null)
       {
-         throw (new QNotFoundException("The input record [" + input.getCodeReference().getRecordTable() + "][" + input.getCodeReference().getRecordPrimaryKey()
-            + "] does not have a script specified for [" + input.getCodeReference().getFieldName() + "]"));
+         input.getAssociatedScriptContextPrimerInterface().primeContext(executeCodeInput, scriptRevision);
       }
 
-      Script script = getScript(input, scriptId);
-      if(script.getCurrentScriptRevisionId() == null)
-      {
-         throw (new QNotFoundException("The script for record [" + input.getCodeReference().getRecordTable() + "][" + input.getCodeReference().getRecordPrimaryKey()
-            + "] (scriptId=" + scriptId + ") does not have a current version."));
-      }
-
-      ScriptRevision scriptRevision = getCurrentScriptRevision(input, script.getCurrentScriptRevisionId());
-
-      ExecuteCodeInput executeCodeInput = new ExecuteCodeInput(input.getInstance());
-      executeCodeInput.setSession(input.getSession());
-      executeCodeInput.setInput(new HashMap<>(input.getInputValues()));
-      executeCodeInput.setContext(new HashMap<>());
-      if(input.getOutputObject() != null)
-      {
-         executeCodeInput.getContext().put("output", input.getOutputObject());
-      }
-      executeCodeInput.setCodeReference(new QCodeReference().withInlineCode(scriptRevision.getContents()).withCodeType(QCodeType.JAVA_SCRIPT)); // todo - code type as attribute of script!!
-      executeCodeInput.setExecutionLogger(new StoreScriptLogAndScriptLogLineExecutionLogger(scriptRevision.getScriptId(), scriptRevision.getId()));
       ExecuteCodeOutput executeCodeOutput = new ExecuteCodeOutput();
       new ExecuteCodeAction().run(executeCodeInput, executeCodeOutput);
 
@@ -88,15 +72,45 @@ public class RunAssociatedScriptAction
 
 
 
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private ScriptRevision getScriptRevision(RunAssociatedScriptInput input) throws QException
+   {
+      if(!scriptRevisionCache.containsKey(input.getCodeReference()))
+      {
+         Serializable scriptId = getScriptId(input);
+         if(scriptId == null)
+         {
+            throw (new QNotFoundException("The input record [" + input.getCodeReference().getRecordTable() + "][" + input.getCodeReference().getRecordPrimaryKey()
+               + "] does not have a script specified for [" + input.getCodeReference().getFieldName() + "]"));
+         }
+
+         Script script = getScript(input, scriptId);
+         if(script.getCurrentScriptRevisionId() == null)
+         {
+            throw (new QNotFoundException("The script for record [" + input.getCodeReference().getRecordTable() + "][" + input.getCodeReference().getRecordPrimaryKey()
+               + "] (scriptId=" + scriptId + ") does not have a current version."));
+         }
+
+         ScriptRevision scriptRevision = getCurrentScriptRevision(input, script.getCurrentScriptRevisionId());
+         scriptRevisionCache.put(input.getCodeReference(), scriptRevision);
+      }
+
+      return scriptRevisionCache.get(input.getCodeReference());
+   }
+
+
+
    /*******************************************************************************
     **
     *******************************************************************************/
    private ScriptRevision getCurrentScriptRevision(RunAssociatedScriptInput input, Serializable scriptRevisionId) throws QException
    {
-      GetInput getInput = new GetInput(input.getInstance());
-      getInput.setSession(input.getSession());
+      GetInput getInput = new GetInput();
       getInput.setTableName("scriptRevision");
       getInput.setPrimaryKey(scriptRevisionId);
+      getInput.setIncludeAssociations(true);
       GetOutput getOutput = new GetAction().execute(getInput);
       if(getOutput.getRecord() == null)
       {
@@ -114,8 +128,7 @@ public class RunAssociatedScriptAction
     *******************************************************************************/
    private Script getScript(RunAssociatedScriptInput input, Serializable scriptId) throws QException
    {
-      GetInput getInput = new GetInput(input.getInstance());
-      getInput.setSession(input.getSession());
+      GetInput getInput = new GetInput();
       getInput.setTableName("script");
       getInput.setPrimaryKey(scriptId);
       GetOutput getOutput = new GetAction().execute(getInput);
@@ -136,8 +149,7 @@ public class RunAssociatedScriptAction
     *******************************************************************************/
    private Serializable getScriptId(RunAssociatedScriptInput input) throws QException
    {
-      GetInput getInput = new GetInput(input.getInstance());
-      getInput.setSession(input.getSession());
+      GetInput getInput = new GetInput();
       getInput.setTableName(input.getCodeReference().getRecordTable());
       getInput.setPrimaryKey(input.getCodeReference().getRecordPrimaryKey());
       GetOutput getOutput = new GetAction().execute(getInput);

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/scripts/StoreAssociatedScriptAction.java

@@ -31,6 +31,8 @@ import com.kingsrook.qqq.backend.core.actions.tables.InsertAction;
 import com.kingsrook.qqq.backend.core.actions.tables.QueryAction;
 import com.kingsrook.qqq.backend.core.actions.tables.UpdateAction;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.model.actions.processes.RunBackendStepInput;
+import com.kingsrook.qqq.backend.core.model.actions.processes.RunBackendStepOutput;
 import com.kingsrook.qqq.backend.core.model.actions.scripts.StoreAssociatedScriptInput;
 import com.kingsrook.qqq.backend.core.model.actions.scripts.StoreAssociatedScriptOutput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.get.GetInput;
@@ -47,6 +49,7 @@ import com.kingsrook.qqq.backend.core.model.actions.tables.update.UpdateInput;
 import com.kingsrook.qqq.backend.core.model.data.QRecord;
 import com.kingsrook.qqq.backend.core.model.metadata.tables.AssociatedScript;
 import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
+import com.kingsrook.qqq.backend.core.processes.implementations.scripts.StoreScriptRevisionProcessStep;
 import com.kingsrook.qqq.backend.core.utils.StringUtils;
 
 
@@ -83,8 +86,7 @@ public class StoreAssociatedScriptAction
       /////////////////////////////////////////////////////////////
       QRecord associatedRecord;
       {
-         GetInput getInput = new GetInput(input.getInstance());
-         getInput.setSession(input.getSession());
+         GetInput getInput = new GetInput();
          getInput.setTableName(input.getTableName());
          getInput.setPrimaryKey(input.getRecordPrimaryKey());
          getInput.setShouldGenerateDisplayValues(true);
@@ -107,8 +109,7 @@ public class StoreAssociatedScriptAction
          ////////////////////////////////////////////////////////////////////
          // get the script type - that'll be part of the new script's name //
          ////////////////////////////////////////////////////////////////////
-         GetInput getInput = new GetInput(input.getInstance());
-         getInput.setSession(input.getSession());
+         GetInput getInput = new GetInput();
          getInput.setTableName("scriptType");
          getInput.setPrimaryKey(associatedScript.getScriptTypeId());
          getInput.setShouldGenerateDisplayValues(true);
@@ -125,8 +126,7 @@ public class StoreAssociatedScriptAction
          script = new QRecord();
          script.setValue("scriptTypeId", associatedScript.getScriptTypeId());
          script.setValue("name", associatedRecord.getRecordLabel() + " - " + scriptType.getRecordLabel());
-         InsertInput insertInput = new InsertInput(input.getInstance());
-         insertInput.setSession(input.getSession());
+         InsertInput insertInput = new InsertInput();
          insertInput.setTableName("script");
          insertInput.setRecords(List.of(script));
          InsertOutput insertOutput = new InsertAction().execute(insertInput);
@@ -135,8 +135,7 @@ public class StoreAssociatedScriptAction
          /////////////////////////////////////////////////////////////
          // update the associated record to point at the new script //
          /////////////////////////////////////////////////////////////
-         UpdateInput updateInput = new UpdateInput(input.getInstance());
-         updateInput.setSession(input.getSession());
+         UpdateInput updateInput = new UpdateInput();
          updateInput.setTableName(input.getTableName());
          updateInput.setRecords(List.of(new QRecord()
             .withValue(table.getPrimaryKeyField(), associatedRecord.getValue(table.getPrimaryKeyField()))
@@ -149,21 +148,18 @@ public class StoreAssociatedScriptAction
          ////////////////////////////////////////
          // get the existing script, to update //
          ////////////////////////////////////////
-         GetInput getInput = new GetInput(input.getInstance());
-         getInput.setSession(input.getSession());
+         GetInput getInput = new GetInput();
          getInput.setTableName("script");
          getInput.setPrimaryKey(existingScriptId);
          GetOutput getOutput = new GetAction().execute(getInput);
          script = getOutput.getRecord();
 
-         QueryInput queryInput = new QueryInput(input.getInstance());
-         queryInput.setSession(input.getSession());
+         QueryInput queryInput = new QueryInput();
          queryInput.setTableName("scriptRevision");
          queryInput.setFilter(new QQueryFilter()
             .withCriteria(new QFilterCriteria("scriptId", QCriteriaOperator.EQUALS, List.of(script.getValue("id"))))
             .withOrderBy(new QFilterOrderBy("sequenceNo", false))
-         );
-         queryInput.setLimit(1);
+            .withLimit(1));
          QueryOutput queryOutput = new QueryAction().execute(queryInput);
          if(!queryOutput.getRecords().isEmpty())
          {
@@ -187,41 +183,19 @@ public class StoreAssociatedScriptAction
          }
       }
 
-      QRecord scriptRevision = new QRecord()
-         .withValue("scriptId", script.getValue("id"))
-         .withValue("contents", input.getCode())
-         .withValue("commitMessage", commitMessage)
-         .withValue("sequenceNo", nextSequenceNo);
-
-      try
-      {
-         scriptRevision.setValue("author", input.getSession().getUser().getFullName());
-      }
-      catch(Exception e)
-      {
-         scriptRevision.setValue("author", "Unknown");
-      }
-
-      InsertInput insertInput = new InsertInput(input.getInstance());
-      insertInput.setSession(input.getSession());
-      insertInput.setTableName("scriptRevision");
-      insertInput.setRecords(List.of(scriptRevision));
-      InsertOutput insertOutput = new InsertAction().execute(insertInput);
-      scriptRevision = insertOutput.getRecords().get(0);
-
-      ////////////////////////////////////////////////////
-      // update the script to point at the new revision //
-      ////////////////////////////////////////////////////
-      script.setValue("currentScriptRevisionId", scriptRevision.getValue("id"));
-      UpdateInput updateInput = new UpdateInput(input.getInstance());
-      updateInput.setSession(input.getSession());
-      updateInput.setTableName("script");
-      updateInput.setRecords(List.of(script));
-      new UpdateAction().execute(updateInput);
+      RunBackendStepInput storeScriptRevisionInput = new RunBackendStepInput();
+      storeScriptRevisionInput.addValue("scriptId", script.getValue("id"));
+      storeScriptRevisionInput.addValue("commitMessage", commitMessage);
+      storeScriptRevisionInput.addValue("apiName", input.getApiName());
+      storeScriptRevisionInput.addValue("apiVersion", input.getApiVersion());
+      storeScriptRevisionInput.addValue("fileNames", "script");
+      storeScriptRevisionInput.addValue("fileContents:script", input.getCode());
+      RunBackendStepOutput storeScriptRevisionOutput = new RunBackendStepOutput();
+      new StoreScriptRevisionProcessStep().run(storeScriptRevisionInput, storeScriptRevisionOutput);
 
       output.setScriptId(script.getValueInteger("id"));
       output.setScriptName(script.getValueString("name"));
-      output.setScriptRevisionId(scriptRevision.getValueInteger("id"));
-      output.setScriptRevisionSequenceNo(scriptRevision.getValueInteger("sequenceNo"));
+      output.setScriptRevisionId(storeScriptRevisionOutput.getValueInteger("scriptRevisionId"));
+      output.setScriptRevisionSequenceNo(storeScriptRevisionOutput.getValueInteger("scriptRevisionSequenceNo"));
    }
 }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/scripts/TestScriptActionInterface.java

@@ -32,6 +32,7 @@ import com.kingsrook.qqq.backend.core.model.actions.scripts.ExecuteCodeOutput;
 import com.kingsrook.qqq.backend.core.model.actions.scripts.TestScriptInput;
 import com.kingsrook.qqq.backend.core.model.actions.scripts.TestScriptOutput;
 import com.kingsrook.qqq.backend.core.model.metadata.fields.QFieldMetaData;
+import com.kingsrook.qqq.backend.core.model.scripts.ScriptRevision;
 
 
 /*******************************************************************************
@@ -47,7 +48,7 @@ public interface TestScriptActionInterface
     ** Note - such a method may want or need to put an "output" object into the
     ** executeCodeInput's context map.
     *******************************************************************************/
-   void setupTestScriptInput(TestScriptInput testScriptInput, ExecuteCodeInput executeCodeInput);
+   void setupTestScriptInput(TestScriptInput testScriptInput, ExecuteCodeInput executeCodeInput) throws QException;
 
 
    /*******************************************************************************
@@ -80,20 +81,31 @@ public interface TestScriptActionInterface
     *******************************************************************************/
    default void execute(TestScriptInput input, TestScriptOutput output) throws QException
    {
-      ExecuteCodeInput executeCodeInput = new ExecuteCodeInput(input.getInstance());
-      executeCodeInput.setSession(input.getSession());
+      /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // todo - could this be merged with the various other script runners, to use ExecuteCodeAction.setupExecuteCodeInput?? //
+      /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      ExecuteCodeInput executeCodeInput = new ExecuteCodeInput();
       executeCodeInput.setContext(new HashMap<>());
 
       executeCodeInput.setCodeReference(input.getCodeReference());
       BuildScriptLogAndScriptLogLineExecutionLogger executionLogger = new BuildScriptLogAndScriptLogLineExecutionLogger(null, null);
       executeCodeInput.setExecutionLogger(executionLogger);
 
-      setupTestScriptInput(input, executeCodeInput);
-
-      ExecuteCodeOutput executeCodeOutput = new ExecuteCodeOutput();
-
       try
       {
+         setupTestScriptInput(input, executeCodeInput);
+
+         ScriptRevision scriptRevision = new ScriptRevision().withApiName(input.getApiName()).withApiVersion(input.getApiVersion());
+
+         if(this instanceof AssociatedScriptContextPrimerInterface associatedScriptContextPrimerInterface)
+         {
+            associatedScriptContextPrimerInterface.primeContext(executeCodeInput, scriptRevision);
+         }
+
+         ExecuteCodeOutput executeCodeOutput = new ExecuteCodeOutput();
+
+         ExecuteCodeAction.addApiUtilityToContext(executeCodeInput.getContext(), scriptRevision);
+
          new ExecuteCodeAction().run(executeCodeInput, executeCodeOutput);
          output.setOutputObject(processTestScriptOutput(executeCodeOutput));
       }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/scripts/logging/AccumulatingBuildScriptLogAndScriptLogLineExecutionLogger.java

@@ -0,0 +1,160 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2023.  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.scripts.logging;
+
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.List;
+import com.kingsrook.qqq.backend.core.actions.tables.InsertAction;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
+import com.kingsrook.qqq.backend.core.model.actions.scripts.ExecuteCodeInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.insert.InsertInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.insert.InsertOutput;
+import com.kingsrook.qqq.backend.core.model.data.QRecord;
+
+
+/*******************************************************************************
+ **
+ *******************************************************************************/
+public class AccumulatingBuildScriptLogAndScriptLogLineExecutionLogger extends BuildScriptLogAndScriptLogLineExecutionLogger implements ScriptExecutionLoggerInterface
+{
+   private static final QLogger LOG = QLogger.getLogger(AccumulatingBuildScriptLogAndScriptLogLineExecutionLogger.class);
+
+   private List<QRecord>       scriptLogs     = new ArrayList<>();
+   private List<List<QRecord>> scriptLogLines = new ArrayList<>();
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public AccumulatingBuildScriptLogAndScriptLogLineExecutionLogger()
+   {
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Override
+   public void acceptExecutionStart(ExecuteCodeInput executeCodeInput)
+   {
+      super.acceptExecutionStart(executeCodeInput);
+      super.setScriptLogLines(new ArrayList<>());
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Override
+   public void acceptException(Exception exception)
+   {
+      accumulate(null, exception);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Override
+   public void acceptExecutionEnd(Serializable output)
+   {
+      accumulate(output, null);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private void accumulate(Serializable output, Exception exception)
+   {
+      super.updateHeaderAtEnd(output, exception);
+      scriptLogs.add(super.getScriptLog());
+      scriptLogLines.add(new ArrayList<>(super.getScriptLogLines()));
+      super.getScriptLogLines().clear();
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public void storeAndClear()
+   {
+      try
+      {
+         InsertInput insertInput = new InsertInput();
+         insertInput.setTableName("scriptLog");
+         insertInput.setRecords(scriptLogs);
+         InsertOutput insertOutput = new InsertAction().execute(insertInput);
+
+         List<QRecord> flatScriptLogLines = new ArrayList<>();
+         for(int i = 0; i < insertOutput.getRecords().size(); i++)
+         {
+            QRecord       insertedScriptLog = insertOutput.getRecords().get(i);
+            List<QRecord> subScriptLogLines = scriptLogLines.get(i);
+            subScriptLogLines.forEach(r -> r.setValue("scriptLogId", insertedScriptLog.getValueInteger("id")));
+            flatScriptLogLines.addAll(subScriptLogLines);
+         }
+
+         insertInput = new InsertInput();
+         insertInput.setTableName("scriptLogLine");
+         insertInput.setRecords(flatScriptLogLines);
+         new InsertAction().execute(insertInput);
+      }
+      catch(Exception e)
+      {
+         LOG.warn("Error storing script logs", e);
+      }
+
+      scriptLogs.clear();
+      scriptLogLines.clear();
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Override
+   public void setScriptId(Integer scriptId)
+   {
+      super.setScriptId(scriptId);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Override
+   public void setScriptRevisionId(Integer scriptRevisionId)
+   {
+      super.setScriptRevisionId(scriptRevisionId);
+   }
+}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/scripts/logging/BuildScriptLogAndScriptLogLineExecutionLogger.java

@@ -27,12 +27,11 @@ import java.time.Instant;
 import java.time.temporal.ChronoUnit;
 import java.util.ArrayList;
 import java.util.List;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
 import com.kingsrook.qqq.backend.core.model.actions.scripts.ExecuteCodeInput;
 import com.kingsrook.qqq.backend.core.model.data.QRecord;
 import com.kingsrook.qqq.backend.core.utils.StringUtils;
 import com.kingsrook.qqq.backend.core.utils.ValueUtils;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
 
 
 /*******************************************************************************
@@ -40,9 +39,9 @@ import org.apache.logging.log4j.Logger;
  ** scriptLogLine records - but doesn't insert them.  e.g., useful for testing
  ** (both in junit, and for users in-app).
  *******************************************************************************/
-public class BuildScriptLogAndScriptLogLineExecutionLogger implements QCodeExecutionLoggerInterface
+public class BuildScriptLogAndScriptLogLineExecutionLogger implements QCodeExecutionLoggerInterface, ScriptExecutionLoggerInterface
 {
-   private static final Logger LOG = LogManager.getLogger(BuildScriptLogAndScriptLogLineExecutionLogger.class);
+   private static final QLogger LOG = QLogger.getLogger(BuildScriptLogAndScriptLogLineExecutionLogger.class);
 
    private   QRecord          scriptLog;
    private   List<QRecord>    scriptLogLines = new ArrayList<>();
@@ -218,4 +217,37 @@ public class BuildScriptLogAndScriptLogLineExecutionLogger implements QCodeExecu
    {
       this.scriptLog = scriptLog;
    }
+
+
+
+   /*******************************************************************************
+    ** Setter for scriptLogLines
+    **
+    *******************************************************************************/
+   protected void setScriptLogLines(List<QRecord> scriptLogLines)
+   {
+      this.scriptLogLines = scriptLogLines;
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Override
+   public void setScriptId(Integer scriptId)
+   {
+      this.scriptId = scriptId;
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Override
+   public void setScriptRevisionId(Integer scriptRevisionId)
+   {
+      this.scriptRevisionId = scriptRevisionId;
+   }
 }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/scripts/logging/Log4jCodeExecutionLogger.java

@@ -24,12 +24,11 @@ package com.kingsrook.qqq.backend.core.actions.scripts.logging;
 
 import java.io.Serializable;
 import java.util.UUID;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
 import com.kingsrook.qqq.backend.core.model.actions.scripts.ExecuteCodeInput;
 import com.kingsrook.qqq.backend.core.model.metadata.code.QCodeReference;
 import com.kingsrook.qqq.backend.core.utils.StringUtils;
 import com.kingsrook.qqq.backend.core.utils.ValueUtils;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
 
 
 /*******************************************************************************
@@ -37,11 +36,12 @@ import org.apache.logging.log4j.Logger;
  *******************************************************************************/
 public class Log4jCodeExecutionLogger implements QCodeExecutionLoggerInterface
 {
-   private static final Logger LOG = LogManager.getLogger(Log4jCodeExecutionLogger.class);
+   private static final QLogger LOG = QLogger.getLogger(Log4jCodeExecutionLogger.class);
 
    private QCodeReference qCodeReference;
    private String         uuid = UUID.randomUUID().toString();
 
+   private boolean includeUUID = true;
 
 
    /*******************************************************************************
@@ -53,7 +53,7 @@ public class Log4jCodeExecutionLogger implements QCodeExecutionLoggerInterface
       this.qCodeReference = executeCodeInput.getCodeReference();
 
       String inputString = StringUtils.safeTruncate(ValueUtils.getValueAsString(executeCodeInput.getInput()), 250, "...");
-      LOG.info("Starting script execution: " + qCodeReference.getName() + ", uuid: " + uuid + ", with input: " + inputString);
+      LOG.info("Starting script execution: " + qCodeReference.getName() + (includeUUID ? ", uuid: " + uuid : "") + ", with input: " + inputString);
    }
 
 
@@ -64,7 +64,7 @@ public class Log4jCodeExecutionLogger implements QCodeExecutionLoggerInterface
    @Override
    public void acceptLogLine(String logLine)
    {
-      LOG.info("Script log: " + uuid + ": " + logLine);
+      LOG.info("Script log: " + (includeUUID ? uuid + ": " : "") + logLine);
    }
 
 
@@ -75,7 +75,7 @@ public class Log4jCodeExecutionLogger implements QCodeExecutionLoggerInterface
    @Override
    public void acceptException(Exception exception)
    {
-      LOG.info("Script Exception: " + uuid, exception);
+      LOG.info("Script Exception: " + (includeUUID ? uuid : ""), exception);
    }
 
 
@@ -87,7 +87,38 @@ public class Log4jCodeExecutionLogger implements QCodeExecutionLoggerInterface
    public void acceptExecutionEnd(Serializable output)
    {
       String outputString = StringUtils.safeTruncate(ValueUtils.getValueAsString(output), 250, "...");
-      LOG.info("Finished script execution: " + qCodeReference.getName() + ", uuid: " + uuid + ", with output: " + outputString);
+      LOG.info("Finished script execution: " + qCodeReference.getName() + (includeUUID ? ", uuid: " + uuid : "") + ", with output: " + outputString);
+   }
+
+
+
+   /*******************************************************************************
+    ** Getter for includeUUID
+    *******************************************************************************/
+   public boolean getIncludeUUID()
+   {
+      return (this.includeUUID);
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for includeUUID
+    *******************************************************************************/
+   public void setIncludeUUID(boolean includeUUID)
+   {
+      this.includeUUID = includeUUID;
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for includeUUID
+    *******************************************************************************/
+   public Log4jCodeExecutionLogger withIncludeUUID(boolean includeUUID)
+   {
+      this.includeUUID = includeUUID;
+      return (this);
    }
 
 }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/scripts/logging/QCodeExecutionLoggerInterface.java

@@ -29,7 +29,7 @@ import com.kingsrook.qqq.backend.core.model.actions.scripts.ExecuteCodeInput;
 /*******************************************************************************
  ** Interface to provide logging functionality to QCodeExecution (e.g., scripts)
  *******************************************************************************/
-public interface QCodeExecutionLoggerInterface
+public interface QCodeExecutionLoggerInterface extends Serializable
 {
 
    /*******************************************************************************

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/scripts/logging/ScriptExecutionLoggerInterface.java

@@ -0,0 +1,39 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2023.  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.scripts.logging;
+
+
+/*******************************************************************************
+ **
+ *******************************************************************************/
+public interface ScriptExecutionLoggerInterface
+{
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   void setScriptId(Integer scriptId);
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   void setScriptRevisionId(Integer scriptRevisionId);
+}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/scripts/logging/StoreScriptLogAndScriptLogLineExecutionLogger.java

@@ -26,13 +26,12 @@ import java.io.Serializable;
 import java.util.List;
 import com.kingsrook.qqq.backend.core.actions.tables.InsertAction;
 import com.kingsrook.qqq.backend.core.actions.tables.UpdateAction;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
 import com.kingsrook.qqq.backend.core.model.actions.scripts.ExecuteCodeInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.insert.InsertInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.insert.InsertOutput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.update.UpdateInput;
 import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
 
 
 /*******************************************************************************
@@ -41,7 +40,7 @@ import org.apache.logging.log4j.Logger;
  *******************************************************************************/
 public class StoreScriptLogAndScriptLogLineExecutionLogger extends BuildScriptLogAndScriptLogLineExecutionLogger
 {
-   private static final Logger LOG = LogManager.getLogger(StoreScriptLogAndScriptLogLineExecutionLogger.class);
+   private static final QLogger LOG = QLogger.getLogger(StoreScriptLogAndScriptLogLineExecutionLogger.class);
 
 
 
@@ -66,8 +65,7 @@ public class StoreScriptLogAndScriptLogLineExecutionLogger extends BuildScriptLo
       {
          super.acceptExecutionStart(executeCodeInput);
 
-         InsertInput insertInput = new InsertInput(executeCodeInput.getInstance());
-         insertInput.setSession(executeCodeInput.getSession());
+         InsertInput insertInput = new InsertInput();
          insertInput.setTableName("scriptLog");
          insertInput.setRecords(List.of(getScriptLog()));
          InsertOutput insertOutput = new InsertAction().execute(insertInput);
@@ -112,16 +110,14 @@ public class StoreScriptLogAndScriptLogLineExecutionLogger extends BuildScriptLo
       try
       {
          updateHeaderAtEnd(output, exception);
-         UpdateInput updateInput = new UpdateInput(executeCodeInput.getInstance());
-         updateInput.setSession(executeCodeInput.getSession());
+         UpdateInput updateInput = new UpdateInput();
          updateInput.setTableName("scriptLog");
          updateInput.setRecords(List.of(getScriptLog()));
          new UpdateAction().execute(updateInput);
 
          if(CollectionUtils.nullSafeHasContents(getScriptLogLines()))
          {
-            InsertInput insertInput = new InsertInput(executeCodeInput.getInstance());
-            insertInput.setSession(executeCodeInput.getSession());
+            InsertInput insertInput = new InsertInput();
             insertInput.setTableName("scriptLogLine");
             insertInput.setRecords(getScriptLogLines());
             new InsertAction().execute(insertInput);

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/scripts/logging/SystemOutExecutionLogger.java

@@ -0,0 +1,88 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2022.  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.scripts.logging;
+
+
+import java.io.Serializable;
+import com.kingsrook.qqq.backend.core.model.actions.scripts.ExecuteCodeInput;
+import com.kingsrook.qqq.backend.core.model.metadata.code.QCodeReference;
+import com.kingsrook.qqq.backend.core.utils.ValueUtils;
+
+
+/*******************************************************************************
+ ** Implementation of a code execution logger that logs to System.out and
+ ** System.err (for exceptions)
+ *******************************************************************************/
+public class SystemOutExecutionLogger implements QCodeExecutionLoggerInterface
+{
+   private QCodeReference qCodeReference;
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Override
+   public void acceptExecutionStart(ExecuteCodeInput executeCodeInput)
+   {
+      this.qCodeReference = executeCodeInput.getCodeReference();
+
+      String inputString = ValueUtils.getValueAsString(executeCodeInput.getInput());
+      System.out.println("Starting script execution: " + qCodeReference.getName() + ", with input: " + inputString);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Override
+   public void acceptLogLine(String logLine)
+   {
+      System.out.println("Script log: " + logLine);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Override
+   public void acceptException(Exception exception)
+   {
+      System.out.println("Script Exception: " + exception.getMessage());
+      exception.printStackTrace();
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Override
+   public void acceptExecutionEnd(Serializable output)
+   {
+      String outputString = ValueUtils.getValueAsString(output);
+      System.out.println("Finished script execution: " + qCodeReference.getName() + ", with output: " + outputString);
+   }
+
+}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/tables/AggregateAction.java

@@ -23,9 +23,15 @@ package com.kingsrook.qqq.backend.core.actions.tables;
 
 
 import com.kingsrook.qqq.backend.core.actions.ActionHelper;
+import com.kingsrook.qqq.backend.core.actions.interfaces.AggregateInterface;
+import com.kingsrook.qqq.backend.core.actions.tables.helpers.QueryStatManager;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
 import com.kingsrook.qqq.backend.core.model.actions.tables.aggregate.AggregateInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.aggregate.AggregateOutput;
+import com.kingsrook.qqq.backend.core.model.metadata.QBackendMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
+import com.kingsrook.qqq.backend.core.model.querystats.QueryStat;
 import com.kingsrook.qqq.backend.core.modules.backend.QBackendModuleDispatcher;
 import com.kingsrook.qqq.backend.core.modules.backend.QBackendModuleInterface;
 
@@ -36,6 +42,12 @@ import com.kingsrook.qqq.backend.core.modules.backend.QBackendModuleInterface;
  *******************************************************************************/
 public class AggregateAction
 {
+   private static final QLogger LOG = QLogger.getLogger(AggregateAction.class);
+
+   private AggregateInterface aggregateInterface;
+
+
+
    /*******************************************************************************
     **
     *******************************************************************************/
@@ -43,11 +55,36 @@ public class AggregateAction
    {
       ActionHelper.validateSession(aggregateInput);
 
+      QTableMetaData   table   = aggregateInput.getTable();
+      QBackendMetaData backend = aggregateInput.getBackend();
+
+      QueryStat queryStat = QueryStatManager.newQueryStat(backend, table, aggregateInput.getFilter());
+
       QBackendModuleDispatcher qBackendModuleDispatcher = new QBackendModuleDispatcher();
       QBackendModuleInterface  qModule                  = qBackendModuleDispatcher.getQBackendModule(aggregateInput.getBackend());
-      // todo pre-customization - just get to modify the request?
-      AggregateOutput aggregateOutput = qModule.getAggregateInterface().execute(aggregateInput);
-      // todo post-customization - can do whatever w/ the result if you want
+
+      aggregateInterface = qModule.getAggregateInterface();
+      aggregateInterface.setQueryStat(queryStat);
+      AggregateOutput aggregateOutput = aggregateInterface.execute(aggregateInput);
+
+      QueryStatManager.getInstance().add(queryStat);
+
       return aggregateOutput;
    }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public void cancel()
+   {
+      if(aggregateInterface == null)
+      {
+         LOG.warn("aggregateInterface object was null when requested to cancel");
+         return;
+      }
+
+      aggregateInterface.cancelAction();
+   }
 }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/tables/CountAction.java

@@ -23,9 +23,15 @@ package com.kingsrook.qqq.backend.core.actions.tables;
 
 
 import com.kingsrook.qqq.backend.core.actions.ActionHelper;
+import com.kingsrook.qqq.backend.core.actions.interfaces.CountInterface;
+import com.kingsrook.qqq.backend.core.actions.tables.helpers.QueryStatManager;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
 import com.kingsrook.qqq.backend.core.model.actions.tables.count.CountInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.count.CountOutput;
+import com.kingsrook.qqq.backend.core.model.metadata.QBackendMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
+import com.kingsrook.qqq.backend.core.model.querystats.QueryStat;
 import com.kingsrook.qqq.backend.core.modules.backend.QBackendModuleDispatcher;
 import com.kingsrook.qqq.backend.core.modules.backend.QBackendModuleInterface;
 
@@ -36,6 +42,12 @@ import com.kingsrook.qqq.backend.core.modules.backend.QBackendModuleInterface;
  *******************************************************************************/
 public class CountAction
 {
+   private static final QLogger LOG = QLogger.getLogger(CountAction.class);
+
+   private CountInterface countInterface;
+
+
+
    /*******************************************************************************
     **
     *******************************************************************************/
@@ -43,11 +55,36 @@ public class CountAction
    {
       ActionHelper.validateSession(countInput);
 
+      QTableMetaData   table   = countInput.getTable();
+      QBackendMetaData backend = countInput.getBackend();
+
+      QueryStat queryStat = QueryStatManager.newQueryStat(backend, table, countInput.getFilter());
+
       QBackendModuleDispatcher qBackendModuleDispatcher = new QBackendModuleDispatcher();
-      QBackendModuleInterface qModule = qBackendModuleDispatcher.getQBackendModule(countInput.getBackend());
-      // todo pre-customization - just get to modify the request?
-      CountOutput countOutput = qModule.getCountInterface().execute(countInput);
-      // todo post-customization - can do whatever w/ the result if you want
+      QBackendModuleInterface  qModule                  = qBackendModuleDispatcher.getQBackendModule(countInput.getBackend());
+
+      countInterface = qModule.getCountInterface();
+      countInterface.setQueryStat(queryStat);
+      CountOutput countOutput = countInterface.execute(countInput);
+
+      QueryStatManager.getInstance().add(queryStat);
+
       return countOutput;
    }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public void cancel()
+   {
+      if(countInterface == null)
+      {
+         LOG.warn("countInterface object was null when requested to cancel");
+         return;
+      }
+
+      countInterface.cancelAction();
+   }
 }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/tables/DeleteAction.java

@@ -24,19 +24,46 @@ package com.kingsrook.qqq.backend.core.actions.tables;
 
 import java.io.Serializable;
 import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Collectors;
 import com.kingsrook.qqq.backend.core.actions.ActionHelper;
+import com.kingsrook.qqq.backend.core.actions.audits.DMLAuditAction;
+import com.kingsrook.qqq.backend.core.actions.customizers.AbstractPostDeleteCustomizer;
+import com.kingsrook.qqq.backend.core.actions.customizers.AbstractPreDeleteCustomizer;
+import com.kingsrook.qqq.backend.core.actions.customizers.QCodeLoader;
+import com.kingsrook.qqq.backend.core.actions.customizers.TableCustomizers;
 import com.kingsrook.qqq.backend.core.actions.interfaces.DeleteInterface;
+import com.kingsrook.qqq.backend.core.actions.tables.helpers.ValidateRecordSecurityLockHelper;
+import com.kingsrook.qqq.backend.core.context.QContext;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.logging.LogPair;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
+import com.kingsrook.qqq.backend.core.model.actions.audits.DMLAuditInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.delete.DeleteInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.delete.DeleteOutput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QCriteriaOperator;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QFilterCriteria;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QQueryFilter;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryOutput;
+import com.kingsrook.qqq.backend.core.model.data.QRecord;
+import com.kingsrook.qqq.backend.core.model.metadata.fields.QFieldMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.joins.QJoinMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.tables.Association;
+import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
+import com.kingsrook.qqq.backend.core.model.statusmessages.NotFoundStatusMessage;
+import com.kingsrook.qqq.backend.core.model.statusmessages.QWarningMessage;
 import com.kingsrook.qqq.backend.core.modules.backend.QBackendModuleDispatcher;
 import com.kingsrook.qqq.backend.core.modules.backend.QBackendModuleInterface;
 import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
+import com.kingsrook.qqq.backend.core.utils.ValueUtils;
 
 
 /*******************************************************************************
@@ -45,7 +72,7 @@ import org.apache.logging.log4j.Logger;
  *******************************************************************************/
 public class DeleteAction
 {
-   private static final Logger LOG = LogManager.getLogger(DeleteAction.class);
+   private static final QLogger LOG = QLogger.getLogger(DeleteAction.class);
 
 
 
@@ -56,21 +83,50 @@ public class DeleteAction
    {
       ActionHelper.validateSession(deleteInput);
 
-      QBackendModuleDispatcher qBackendModuleDispatcher = new QBackendModuleDispatcher();
-      QBackendModuleInterface  qModule                  = qBackendModuleDispatcher.getQBackendModule(deleteInput.getBackend());
-      // todo pre-customization - just get to modify the request?
+      QTableMetaData table               = deleteInput.getTable();
+      String         primaryKeyFieldName = table.getPrimaryKeyField();
+      QFieldMetaData primaryKeyField     = table.getField(primaryKeyFieldName);
 
-      if(CollectionUtils.nullSafeHasContents(deleteInput.getPrimaryKeys()) && deleteInput.getQueryFilter() != null)
+      List<Serializable> primaryKeys         = deleteInput.getPrimaryKeys();
+      List<Serializable> originalPrimaryKeys = primaryKeys == null ? null : new ArrayList<>(primaryKeys);
+      if(CollectionUtils.nullSafeHasContents(primaryKeys) && deleteInput.getQueryFilter() != null)
       {
          throw (new QException("A delete request may not contain both a list of primary keys and a query filter."));
       }
 
-      DeleteInterface deleteInterface = qModule.getDeleteInterface();
-      if(deleteInput.getQueryFilter() != null && !deleteInterface.supportsQueryFilterInput())
+      ////////////////////////////////////////////////////////
+      // make sure the primary keys are of the correct type //
+      ////////////////////////////////////////////////////////
+      if(CollectionUtils.nullSafeHasContents(primaryKeys))
       {
-         LOG.info("Querying for primary keys, for backend module " + qModule.getBackendType() + " which does not support queryFilter input for deletes");
+         for(int i = 0; i < primaryKeys.size(); i++)
+         {
+            Serializable primaryKey       = primaryKeys.get(i);
+            Serializable valueAsFieldType = ValueUtils.getValueAsFieldType(primaryKeyField.getType(), primaryKey);
+            if(!Objects.equals(primaryKey, valueAsFieldType))
+            {
+               primaryKeys.set(i, valueAsFieldType);
+            }
+         }
+      }
+
+      //////////////////////////////////////////////////////
+      // load the backend module and its delete interface //
+      //////////////////////////////////////////////////////
+      QBackendModuleDispatcher qBackendModuleDispatcher = new QBackendModuleDispatcher();
+      QBackendModuleInterface  qModule                  = qBackendModuleDispatcher.getQBackendModule(deleteInput.getBackend());
+      DeleteInterface          deleteInterface          = qModule.getDeleteInterface();
+
+      //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // if there's a query filter, but the interface doesn't support using a query filter, then do a query for the filter, to get a list of primary keys instead //
+      // or - anytime there are associations on the table we want primary keys, as that's what the manage associations method uses                                //
+      //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      if(deleteInput.getQueryFilter() != null && (!deleteInterface.supportsQueryFilterInput() || CollectionUtils.nullSafeHasContents(table.getAssociations())))
+      {
+         LOG.info("Querying for primary keys, for table " + table.getName() + " in backend module " + qModule.getBackendType() + " which does not support queryFilter input for deletes (or the table has associations)");
          List<Serializable> primaryKeyList = getPrimaryKeysFromQueryFilter(deleteInput);
          deleteInput.setPrimaryKeys(primaryKeyList);
+         primaryKeys = primaryKeyList;
 
          if(primaryKeyList.isEmpty())
          {
@@ -82,10 +138,348 @@ public class DeleteAction
          }
       }
 
-      DeleteOutput deleteResult = deleteInterface.execute(deleteInput);
-      // todo post-customization - can do whatever w/ the result if you want
+      ////////////////////////////////////////////////////////////////////////////////
+      // fetch the old list of records (if the backend supports it), for audits,    //
+      // for "not-found detection", and for the pre-action to use (if there is one) //
+      ////////////////////////////////////////////////////////////////////////////////
+      Optional<List<QRecord>> oldRecordList = fetchOldRecords(deleteInput, deleteInterface);
 
-      return deleteResult;
+      List<QRecord>              customizerResult              = performValidations(deleteInput, oldRecordList, false);
+      List<QRecord>              recordsWithValidationErrors   = new ArrayList<>();
+      Map<Serializable, QRecord> recordsWithValidationWarnings = new LinkedHashMap<>();
+
+      ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // check if any records got errors in the customizer - if so, remove them from the input list of pkeys to delete //
+      ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      if(customizerResult != null)
+      {
+         Set<Serializable> primaryKeysToRemoveFromInput = new HashSet<>();
+         for(QRecord record : customizerResult)
+         {
+            if(CollectionUtils.nullSafeHasContents(record.getErrors()))
+            {
+               recordsWithValidationErrors.add(record);
+               primaryKeysToRemoveFromInput.add(record.getValue(primaryKeyFieldName));
+            }
+            else if(CollectionUtils.nullSafeHasContents(record.getWarnings()))
+            {
+               recordsWithValidationWarnings.put(record.getValue(primaryKeyFieldName), record);
+            }
+         }
+
+         if(!primaryKeysToRemoveFromInput.isEmpty())
+         {
+            if(primaryKeys == null)
+            {
+               LOG.warn("There were primary keys to remove from the input, but no primary key list (filter supplied as input?)", new LogPair("primaryKeysToRemoveFromInput", primaryKeysToRemoveFromInput));
+            }
+            else
+            {
+               primaryKeys.removeAll(primaryKeysToRemoveFromInput);
+            }
+         }
+      }
+
+      ////////////////////////////////////////////////////////////////////////////////////////////////
+      // stash a copy of primary keys that didn't have errors (for use in manageAssociations below) //
+      ////////////////////////////////////////////////////////////////////////////////////////////////
+      Set<Serializable> primaryKeysWithoutErrors = new HashSet<>(CollectionUtils.nonNullList(primaryKeys));
+
+      ////////////////////////////////////
+      // have the backend do the delete //
+      ////////////////////////////////////
+      DeleteOutput deleteOutput = deleteInterface.execute(deleteInput);
+
+      /////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // reset the input's list of primary keys -- callers may use & expect that to be what they had passed in!! //
+      /////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      deleteInput.setPrimaryKeys(originalPrimaryKeys);
+
+      ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // merge the backend's output with any validation errors we found (whose pkeys wouldn't have gotten into the backend delete) //
+      ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      List<QRecord> outputRecordsWithErrors = Objects.requireNonNullElseGet(deleteOutput.getRecordsWithErrors(), () -> new ArrayList<>());
+      outputRecordsWithErrors.addAll(recordsWithValidationErrors);
+
+      ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // if a record had a validation warning, but then an execution error, remove it from the warning list - so it's only in one of them. //
+      // also, always remove from
+      ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      for(QRecord outputRecordWithError : outputRecordsWithErrors)
+      {
+         Serializable pkey = outputRecordWithError.getValue(primaryKeyFieldName);
+         recordsWithValidationWarnings.remove(pkey);
+         primaryKeysWithoutErrors.remove(pkey);
+      }
+
+      ///////////////////////////////////////////////////////////////////////////////////////////
+      // combine the warning list from validation to that from execution - avoiding duplicates //
+      // use a map to manage this list for the rest of this method                             //
+      ///////////////////////////////////////////////////////////////////////////////////////////
+      Map<Serializable, QRecord> outputRecordsWithWarningMap = CollectionUtils.nullSafeIsEmpty(deleteOutput.getRecordsWithWarnings()) ? new LinkedHashMap<>()
+         : deleteOutput.getRecordsWithWarnings().stream().collect(Collectors.toMap(r -> r.getValue(primaryKeyFieldName), r -> r, (a, b) -> a, () -> new LinkedHashMap<>()));
+      for(Map.Entry<Serializable, QRecord> entry : recordsWithValidationWarnings.entrySet())
+      {
+         if(!outputRecordsWithWarningMap.containsKey(entry.getKey()))
+         {
+            outputRecordsWithWarningMap.put(entry.getKey(), entry.getValue());
+         }
+      }
+
+      ////////////////////////////////////////
+      // delete associations, if applicable //
+      ////////////////////////////////////////
+      manageAssociations(primaryKeysWithoutErrors, deleteInput);
+
+      //////////////////
+      // do the audit //
+      //////////////////
+      if(deleteInput.getOmitDmlAudit())
+      {
+         LOG.debug("Requested to omit DML audit");
+      }
+      else
+      {
+         DMLAuditInput dmlAuditInput = new DMLAuditInput()
+            .withTableActionInput(deleteInput)
+            .withAuditContext(deleteInput.getAuditContext());
+         oldRecordList.ifPresent(l -> dmlAuditInput.setRecordList(l));
+         new DMLAuditAction().execute(dmlAuditInput);
+      }
+
+      //////////////////////////////////////////////////////////////
+      // finally, run the post-delete customizer, if there is one //
+      //////////////////////////////////////////////////////////////
+      Optional<AbstractPostDeleteCustomizer> postDeleteCustomizer = QCodeLoader.getTableCustomizer(AbstractPostDeleteCustomizer.class, table, TableCustomizers.POST_DELETE_RECORD.getRole());
+      if(postDeleteCustomizer.isPresent() && oldRecordList.isPresent())
+      {
+         ////////////////////////////////////////////////////////////////////////////
+         // make list of records that are still good - to pass into the customizer //
+         ////////////////////////////////////////////////////////////////////////////
+         List<QRecord> recordsForCustomizer = makeListOfRecordsNotInErrorList(primaryKeyFieldName, oldRecordList.get(), outputRecordsWithErrors);
+
+         try
+         {
+            postDeleteCustomizer.get().setDeleteInput(deleteInput);
+            List<QRecord> postCustomizerResult = postDeleteCustomizer.get().apply(recordsForCustomizer);
+
+            ///////////////////////////////////////////////////////
+            // check if any records got errors in the customizer //
+            ///////////////////////////////////////////////////////
+            for(QRecord record : postCustomizerResult)
+            {
+               Serializable pkey = record.getValue(primaryKeyFieldName);
+               if(CollectionUtils.nullSafeHasContents(record.getErrors()))
+               {
+                  outputRecordsWithErrors.add(record);
+                  outputRecordsWithWarningMap.remove(pkey);
+               }
+               else if(CollectionUtils.nullSafeHasContents(record.getWarnings()))
+               {
+                  outputRecordsWithWarningMap.put(pkey, record);
+               }
+            }
+         }
+         catch(Exception e)
+         {
+            for(QRecord record : recordsForCustomizer)
+            {
+               record.addWarning(new QWarningMessage("An error occurred after the delete: " + e.getMessage()));
+               outputRecordsWithWarningMap.put(record.getValue(primaryKeyFieldName), record);
+            }
+         }
+      }
+
+      deleteOutput.setRecordsWithErrors(outputRecordsWithErrors);
+      deleteOutput.setRecordsWithWarnings(new ArrayList<>(outputRecordsWithWarningMap.values()));
+
+      return deleteOutput;
+   }
+
+
+
+   /*******************************************************************************
+    ** this method takes in the deleteInput, and the list of old records that matched
+    ** the pkeys in that input.
+    **
+    ** it'll check if any of those pkeys aren't found (in a sub-method) - a record
+    ** with an error message will be added to oldRecordList for any such records.
+    **
+    ** it'll also then call the pre-customizer, if there is one - taking in the
+    ** oldRecordList.  it can add other errors or warnings to records.
+    **
+    ** The return value here is basically oldRecordList - possibly with some new
+    ** entries for the pkey-not-founds, and possibly w/ errors and warnings from the
+    ** customizer.
+    *******************************************************************************/
+   public List<QRecord> performValidations(DeleteInput deleteInput, Optional<List<QRecord>> oldRecordList, boolean isPreview) throws QException
+   {
+      if(oldRecordList.isEmpty())
+      {
+         return (null);
+      }
+
+      QTableMetaData table               = deleteInput.getTable();
+      List<QRecord>  primaryKeysNotFound = validateRecordsExistAndCanBeAccessed(deleteInput, oldRecordList.get());
+
+      ValidateRecordSecurityLockHelper.validateSecurityFields(table, oldRecordList.get(), ValidateRecordSecurityLockHelper.Action.DELETE);
+
+      ///////////////////////////////////////////////////////////////////////////
+      // after all validations, run the pre-delete customizer, if there is one //
+      ///////////////////////////////////////////////////////////////////////////
+      Optional<AbstractPreDeleteCustomizer> preDeleteCustomizer = QCodeLoader.getTableCustomizer(AbstractPreDeleteCustomizer.class, table, TableCustomizers.PRE_DELETE_RECORD.getRole());
+      List<QRecord>                         customizerResult    = oldRecordList.get();
+      if(preDeleteCustomizer.isPresent())
+      {
+         preDeleteCustomizer.get().setDeleteInput(deleteInput);
+         preDeleteCustomizer.get().setIsPreview(isPreview);
+         customizerResult = preDeleteCustomizer.get().apply(oldRecordList.get());
+      }
+
+      /////////////////////////////////////////////////////////////////////////
+      // add any pkey-not-found records to the front of the customizerResult //
+      /////////////////////////////////////////////////////////////////////////
+      customizerResult.addAll(primaryKeysNotFound);
+
+      return customizerResult;
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private static List<QRecord> makeListOfRecordsNotInErrorList(String primaryKeyField, List<QRecord> oldRecordList, List<QRecord> outputRecordsWithErrors)
+   {
+      Map<Serializable, QRecord> recordsWithErrorsMap = outputRecordsWithErrors.stream().collect(Collectors.toMap(r -> r.getValue(primaryKeyField), r -> r));
+      List<QRecord>              recordsForCustomizer = new ArrayList<>();
+      for(QRecord record : oldRecordList)
+      {
+         if(!recordsWithErrorsMap.containsKey(record.getValue(primaryKeyField)))
+         {
+            recordsForCustomizer.add(record);
+         }
+      }
+      return recordsForCustomizer;
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private void manageAssociations(Set<Serializable> primaryKeysWithoutErrors, DeleteInput deleteInput) throws QException
+   {
+      QTableMetaData table = deleteInput.getTable();
+      for(Association association : CollectionUtils.nonNullList(table.getAssociations()))
+      {
+         // e.g., order -> orderLine
+         QJoinMetaData join = QContext.getQInstance().getJoin(association.getJoinName()); // todo ... ever need to flip?
+         // just assume this, at least for now... if(BooleanUtils.isTrue(association.getDoInserts()))
+
+         QQueryFilter filter = new QQueryFilter();
+
+         if(join.getJoinOns().size() == 1 && join.getJoinOns().get(0).getLeftField().equals(table.getPrimaryKeyField()))
+         {
+            filter.addCriteria(new QFilterCriteria(join.getJoinOns().get(0).getRightField(), QCriteriaOperator.IN, new ArrayList<>(primaryKeysWithoutErrors)));
+         }
+         else
+         {
+            throw (new QException("Join of this type is not supported for an associated delete at this time..."));
+         }
+
+         QTableMetaData associatedTable = QContext.getQInstance().getTable(association.getAssociatedTableName());
+
+         QueryInput queryInput = new QueryInput();
+         queryInput.setTransaction(deleteInput.getTransaction());
+         queryInput.setTableName(association.getAssociatedTableName());
+         queryInput.setFilter(filter);
+         QueryOutput        queryOutput    = new QueryAction().execute(queryInput);
+         List<Serializable> associatedKeys = queryOutput.getRecords().stream().map(r -> r.getValue(associatedTable.getPrimaryKeyField())).toList();
+
+         if(CollectionUtils.nullSafeHasContents(associatedKeys))
+         {
+            DeleteInput nextLevelDeleteInput = new DeleteInput();
+            nextLevelDeleteInput.setTransaction(deleteInput.getTransaction());
+            nextLevelDeleteInput.setTableName(association.getAssociatedTableName());
+            nextLevelDeleteInput.setPrimaryKeys(associatedKeys);
+            DeleteOutput nextLevelDeleteOutput = new DeleteAction().execute(nextLevelDeleteInput);
+         }
+      }
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private static Optional<List<QRecord>> fetchOldRecords(DeleteInput deleteInput, DeleteInterface deleteInterface) throws QException
+   {
+      if(deleteInterface.supportsPreFetchQuery())
+      {
+         List<Serializable> primaryKeyList = deleteInput.getPrimaryKeys();
+         if(CollectionUtils.nullSafeIsEmpty(deleteInput.getPrimaryKeys()) && deleteInput.getQueryFilter() != null)
+         {
+            primaryKeyList = getPrimaryKeysFromQueryFilter(deleteInput);
+         }
+
+         if(CollectionUtils.nullSafeHasContents(primaryKeyList))
+         {
+            QueryInput queryInput = new QueryInput();
+            queryInput.setTransaction(deleteInput.getTransaction());
+            queryInput.setTableName(deleteInput.getTableName());
+            queryInput.setFilter(new QQueryFilter(new QFilterCriteria(deleteInput.getTable().getPrimaryKeyField(), QCriteriaOperator.IN, primaryKeyList)));
+            QueryOutput queryOutput = new QueryAction().execute(queryInput);
+            return (Optional.of(queryOutput.getRecords()));
+         }
+      }
+
+      return (Optional.empty());
+   }
+
+
+
+   /*******************************************************************************
+    ** Note - the "can be accessed" part of this method name - it implies that
+    ** records that you can't see because of security - that they won't be found
+    ** by the query here, so it's the same to you as if they don't exist at all!
+    **
+    ** If this method identifies any missing records (e.g., from PKeys that are
+    ** requested to be deleted, but don't exist (or can't be seen)), then it will
+    ** return those as new QRecords, with error messages.
+    *******************************************************************************/
+   private List<QRecord> validateRecordsExistAndCanBeAccessed(DeleteInput deleteInput, List<QRecord> oldRecordList) throws QException
+   {
+      List<QRecord> recordsWithErrors = new ArrayList<>();
+
+      QTableMetaData table           = deleteInput.getTable();
+      QFieldMetaData primaryKeyField = table.getField(table.getPrimaryKeyField());
+
+      List<List<Serializable>> pages = CollectionUtils.getPages(deleteInput.getPrimaryKeys(), 1000);
+      for(List<Serializable> page : pages)
+      {
+         Map<Serializable, QRecord> oldRecordMapByPrimaryKey = new HashMap<>();
+         for(QRecord record : oldRecordList)
+         {
+            Serializable primaryKeyValue = record.getValue(table.getPrimaryKeyField());
+            primaryKeyValue = ValueUtils.getValueAsFieldType(primaryKeyField.getType(), primaryKeyValue);
+            oldRecordMapByPrimaryKey.put(primaryKeyValue, record);
+         }
+
+         for(Serializable primaryKeyValue : page)
+         {
+            primaryKeyValue = ValueUtils.getValueAsFieldType(primaryKeyField.getType(), primaryKeyValue);
+            if(!oldRecordMapByPrimaryKey.containsKey(primaryKeyValue))
+            {
+               QRecord recordWithError = new QRecord();
+               recordsWithErrors.add(recordWithError);
+               recordWithError.setValue(primaryKeyField.getName(), primaryKeyValue);
+               recordWithError.addError(new NotFoundStatusMessage("No record was found to delete for " + primaryKeyField.getLabel() + " = " + primaryKeyValue));
+            }
+         }
+      }
+
+      return (recordsWithErrors);
    }
 
 
@@ -102,7 +496,8 @@ public class DeleteAction
          QBackendModuleDispatcher qBackendModuleDispatcher = new QBackendModuleDispatcher();
          QBackendModuleInterface  qModule                  = qBackendModuleDispatcher.getQBackendModule(deleteInput.getBackend());
 
-         QueryInput queryInput = new QueryInput(deleteInput.getInstance(), deleteInput.getSession());
+         QueryInput queryInput = new QueryInput();
+         queryInput.setTransaction(deleteInput.getTransaction());
          queryInput.setTableName(deleteInput.getTableName());
          queryInput.setFilter(deleteInput.getQueryFilter());
          QueryOutput queryOutput = qModule.getQueryInterface().execute(queryInput);

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/tables/GetAction.java

@@ -23,8 +23,6 @@ package com.kingsrook.qqq.backend.core.actions.tables;
 
 
 import java.io.Serializable;
-import java.time.Instant;
-import java.time.temporal.ChronoUnit;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
@@ -33,29 +31,24 @@ import com.kingsrook.qqq.backend.core.actions.customizers.AbstractPostQueryCusto
 import com.kingsrook.qqq.backend.core.actions.customizers.QCodeLoader;
 import com.kingsrook.qqq.backend.core.actions.customizers.TableCustomizers;
 import com.kingsrook.qqq.backend.core.actions.interfaces.GetInterface;
+import com.kingsrook.qqq.backend.core.actions.tables.helpers.GetActionCacheHelper;
 import com.kingsrook.qqq.backend.core.actions.values.QPossibleValueTranslator;
 import com.kingsrook.qqq.backend.core.actions.values.QValueFormatter;
+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.delete.DeleteInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.get.GetInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.get.GetOutput;
-import com.kingsrook.qqq.backend.core.model.actions.tables.insert.InsertInput;
-import com.kingsrook.qqq.backend.core.model.actions.tables.insert.InsertOutput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QCriteriaOperator;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QFilterCriteria;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QQueryFilter;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryOutput;
-import com.kingsrook.qqq.backend.core.model.actions.tables.update.UpdateInput;
-import com.kingsrook.qqq.backend.core.model.actions.tables.update.UpdateOutput;
 import com.kingsrook.qqq.backend.core.model.data.QRecord;
+import com.kingsrook.qqq.backend.core.model.metadata.fields.AdornmentType;
+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.model.metadata.tables.cache.CacheUseCase;
 import com.kingsrook.qqq.backend.core.modules.backend.QBackendModuleDispatcher;
 import com.kingsrook.qqq.backend.core.modules.backend.QBackendModuleInterface;
-import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
-import com.kingsrook.qqq.backend.core.utils.StringUtils;
-import org.apache.commons.lang.NotImplementedException;
 
 
 /*******************************************************************************
@@ -67,11 +60,20 @@ public class GetAction
    private Optional<AbstractPostQueryCustomizer> postGetRecordCustomizer;
 
    private GetInput                 getInput;
-   private QValueFormatter          qValueFormatter;
    private QPossibleValueTranslator qPossibleValueTranslator;
 
 
 
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public QRecord executeForRecord(GetInput getInput) throws QException
+   {
+      return (execute(getInput).getRecord());
+   }
+
+
+
    /*******************************************************************************
     **
     *******************************************************************************/
@@ -80,6 +82,11 @@ public class GetAction
       ActionHelper.validateSession(getInput);
 
       QTableMetaData table = getInput.getTable();
+      if(table == null)
+      {
+         throw (new QException("Requested to Get a record from an unrecognized table: " + getInput.getTableName()));
+      }
+
       postGetRecordCustomizer = QCodeLoader.getTableCustomizer(AbstractPostQueryCustomizer.class, table, TableCustomizers.POST_QUERY_RECORD.getRole());
       this.getInput = getInput;
 
@@ -113,31 +120,7 @@ public class GetAction
       ////////////////////////////
       if(table.getCacheOf() != null)
       {
-         if(getOutput.getRecord() == null)
-         {
-            ///////////////////////////////////////////////////////////////////////
-            // if the record wasn't found, see if we should look in cache-source //
-            ///////////////////////////////////////////////////////////////////////
-            QRecord recordFromSource = tryToGetFromCacheSource(getInput, getOutput);
-            if(recordFromSource != null)
-            {
-               QRecord recordToCache = mapSourceRecordToCacheRecord(table, recordFromSource);
-
-               InsertInput insertInput = new InsertInput(getInput.getInstance());
-               insertInput.setSession(getInput.getSession());
-               insertInput.setTableName(getInput.getTableName());
-               insertInput.setRecords(List.of(recordToCache));
-               InsertOutput insertOutput = new InsertAction().execute(insertInput);
-               getOutput.setRecord(insertOutput.getRecords().get(0));
-            }
-         }
-         else
-         {
-            /////////////////////////////////////////////////////////////////////////////////
-            // if the record was found, but it's too old, maybe re-fetch from cache source //
-            /////////////////////////////////////////////////////////////////////////////////
-            refreshCacheIfExpired(getInput, getOutput);
-         }
+         new GetActionCacheHelper().handleCaching(getInput, getOutput);
       }
 
       ////////////////////////////////////////////////////////
@@ -154,110 +137,12 @@ public class GetAction
 
 
    /*******************************************************************************
-    **
+    ** Run a GetAction by using the QueryAction instead (e.g., with a filter made
+    ** from the pkey/ukey, and returning the single record if found).
     *******************************************************************************/
-   private static QRecord mapSourceRecordToCacheRecord(QTableMetaData table, QRecord recordFromSource)
+   public GetOutput executeViaQuery(GetInput getInput) throws QException
    {
-      QRecord cacheRecord = new QRecord(recordFromSource);
-      if(StringUtils.hasContent(table.getCacheOf().getCachedDateFieldName()))
-      {
-         cacheRecord.setValue(table.getCacheOf().getCachedDateFieldName(), Instant.now());
-      }
-      return (cacheRecord);
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   private void refreshCacheIfExpired(GetInput getInput, GetOutput getOutput) throws QException
-   {
-      QTableMetaData table             = getInput.getTable();
-      Integer        expirationSeconds = table.getCacheOf().getExpirationSeconds();
-      if(expirationSeconds != null)
-      {
-         QRecord cachedRecord = getOutput.getRecord();
-         Instant cachedDate   = cachedRecord.getValueInstant(table.getCacheOf().getCachedDateFieldName());
-         if(cachedDate == null || cachedDate.isBefore(Instant.now().minus(expirationSeconds, ChronoUnit.SECONDS)))
-         {
-            QRecord recordFromSource = tryToGetFromCacheSource(getInput, getOutput);
-            if(recordFromSource != null)
-            {
-               ///////////////////////////////////////////////////////////////////
-               // if the record was found in the source, update it in the cache //
-               ///////////////////////////////////////////////////////////////////
-               QRecord recordToCache = mapSourceRecordToCacheRecord(table, recordFromSource);
-               recordToCache.setValue(table.getPrimaryKeyField(), cachedRecord.getValue(table.getPrimaryKeyField()));
-
-               UpdateInput updateInput = new UpdateInput(getInput.getInstance());
-               updateInput.setSession(getInput.getSession());
-               updateInput.setTableName(getInput.getTableName());
-               updateInput.setRecords(List.of(recordToCache));
-               UpdateOutput updateOutput = new UpdateAction().execute(updateInput);
-
-               getOutput.setRecord(updateOutput.getRecords().get(0));
-            }
-            else
-            {
-               /////////////////////////////////////////////////////////////////////////////
-               // if the record is no longer in the source, then remove it from the cache //
-               /////////////////////////////////////////////////////////////////////////////
-               DeleteInput deleteInput = new DeleteInput(getInput.getInstance());
-               deleteInput.setSession(getInput.getSession());
-               deleteInput.setTableName(getInput.getTableName());
-               deleteInput.setPrimaryKeys(List.of(getOutput.getRecord().getValue(table.getPrimaryKeyField())));
-               new DeleteAction().execute(deleteInput);
-
-               getOutput.setRecord(null);
-            }
-         }
-      }
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   private QRecord tryToGetFromCacheSource(GetInput getInput, GetOutput getOutput) throws QException
-   {
-      QRecord        recordFromSource = null;
-      QTableMetaData table            = getInput.getTable();
-
-      for(CacheUseCase cacheUseCase : CollectionUtils.nonNullList(table.getCacheOf().getUseCases()))
-      {
-         if(CacheUseCase.Type.UNIQUE_KEY_TO_UNIQUE_KEY.equals(cacheUseCase.getType()) && getInput.getUniqueKey() != null)
-         {
-            recordFromSource = getFromCachedSourceForUniqueKeyToUniqueKey(getInput, table.getCacheOf().getSourceTable());
-            break;
-         }
-         else
-         {
-            // todo!!
-            throw new NotImplementedException("Not-yet-implemented cache use case type: " + cacheUseCase.getType());
-         }
-      }
-
-      return (recordFromSource);
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   private QRecord getFromCachedSourceForUniqueKeyToUniqueKey(GetInput getInput, String sourceTableName) throws QException
-   {
-      /////////////////////////////////////////////////////
-      // do a Get on the source table, by the unique key //
-      /////////////////////////////////////////////////////
-      GetInput sourceGetInput = new GetInput(getInput.getInstance());
-      sourceGetInput.setSession(getInput.getSession());
-      sourceGetInput.setTableName(sourceTableName);
-      sourceGetInput.setUniqueKey(getInput.getUniqueKey());
-      GetOutput sourceGetOutput = new GetAction().execute(sourceGetInput);
-      return (sourceGetOutput.getRecord());
+      return (new DefaultGetInterface().execute(getInput));
    }
 
 
@@ -270,38 +155,7 @@ public class GetAction
       @Override
       public GetOutput execute(GetInput getInput) throws QException
       {
-         QueryInput queryInput = new QueryInput(getInput.getInstance());
-         queryInput.setSession(getInput.getSession());
-         queryInput.setTableName(getInput.getTableName());
-
-         //////////////////////////////////////////////////
-         // build filter using either pkey or unique key //
-         //////////////////////////////////////////////////
-         QQueryFilter filter = new QQueryFilter();
-         if(getInput.getPrimaryKey() != null)
-         {
-            filter.addCriteria(new QFilterCriteria(getInput.getTable().getPrimaryKeyField(), QCriteriaOperator.EQUALS, getInput.getPrimaryKey()));
-         }
-         else if(getInput.getUniqueKey() != null)
-         {
-            for(Map.Entry<String, Serializable> entry : getInput.getUniqueKey().entrySet())
-            {
-               if(entry.getValue() == null)
-               {
-                  filter.addCriteria(new QFilterCriteria(entry.getKey(), QCriteriaOperator.IS_BLANK));
-               }
-               else
-               {
-                  filter.addCriteria(new QFilterCriteria(entry.getKey(), QCriteriaOperator.EQUALS, entry.getValue()));
-               }
-            }
-         }
-         else
-         {
-            throw (new QException("No primaryKey or uniqueKey was passed to Get"));
-         }
-
-         queryInput.setFilter(filter);
+         QueryInput queryInput = convertGetInputToQueryInput(getInput);
 
          QueryOutput queryOutput = new QueryAction().execute(queryInput);
 
@@ -316,6 +170,48 @@ public class GetAction
 
 
 
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public static QueryInput convertGetInputToQueryInput(GetInput getInput) throws QException
+   {
+      QueryInput queryInput = new QueryInput();
+      queryInput.setTableName(getInput.getTableName());
+
+      //////////////////////////////////////////////////
+      // build filter using either pkey or unique key //
+      //////////////////////////////////////////////////
+      QQueryFilter filter = new QQueryFilter();
+      if(getInput.getPrimaryKey() != null)
+      {
+         filter.addCriteria(new QFilterCriteria(getInput.getTable().getPrimaryKeyField(), QCriteriaOperator.EQUALS, getInput.getPrimaryKey()));
+      }
+      else if(getInput.getUniqueKey() != null)
+      {
+         for(Map.Entry<String, Serializable> entry : getInput.getUniqueKey().entrySet())
+         {
+            if(entry.getValue() == null)
+            {
+               filter.addCriteria(new QFilterCriteria(entry.getKey(), QCriteriaOperator.IS_BLANK));
+            }
+            else
+            {
+               filter.addCriteria(new QFilterCriteria(entry.getKey(), QCriteriaOperator.EQUALS, entry.getValue()));
+            }
+         }
+      }
+      else
+      {
+         throw (new QException("No primaryKey or uniqueKey was passed to Get"));
+      }
+
+      queryInput.setFilter(filter);
+      queryInput.setCommonParamsFrom(getInput);
+      return queryInput;
+   }
+
+
+
    /*******************************************************************************
     ** Run the necessary actions on a record.  This may include setting display values,
     ** translating possible values, and running post-record customizations.
@@ -339,13 +235,39 @@ public class GetAction
 
       if(getInput.getShouldGenerateDisplayValues())
       {
-         if(qValueFormatter == null)
-         {
-            qValueFormatter = new QValueFormatter();
-         }
-         qValueFormatter.setDisplayValuesInRecords(getInput.getTable(), List.of(returnRecord));
+         QValueFormatter.setDisplayValuesInRecords(getInput.getTable(), List.of(returnRecord));
       }
 
+      if(getInput.getShouldOmitHiddenFields() || getInput.getShouldMaskPasswords())
+      {
+         Map<String, QFieldMetaData> fields = QContext.getQInstance().getTable(getInput.getTableName()).getFields();
+         for(String fieldName : fields.keySet())
+         {
+            QFieldMetaData field = fields.get(fieldName);
+            if(getInput.getShouldOmitHiddenFields() && field.getIsHidden())
+            {
+               returnRecord.removeValue(fieldName);
+            }
+            else if(getInput.getShouldMaskPasswords() && field.getType() != null && field.getType().needsMasked() && !field.hasAdornmentType(AdornmentType.REVEAL))
+            {
+               //////////////////////////////////////////////////////////////////////
+               // empty out the value completely first (which will remove from     //
+               // display fields as well) then update display value if flag is set //
+               //////////////////////////////////////////////////////////////////////
+               returnRecord.removeValue(fieldName);
+               returnRecord.setValue(fieldName, "************");
+               if(getInput.getShouldGenerateDisplayValues())
+               {
+                  returnRecord.setDisplayValue(fieldName, record.getValueString(fieldName));
+               }
+            }
+         }
+      }
+
+      //////////////////////////////////////////////////////////////////////////////
+      // note - shouldFetchHeavyFields should be handled by the underlying action //
+      //////////////////////////////////////////////////////////////////////////////
+
       return (returnRecord);
    }
 }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/tables/InsertAction.java

@@ -23,33 +23,49 @@ package com.kingsrook.qqq.backend.core.actions.tables;
 
 
 import java.io.Serializable;
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
+import java.util.stream.Collectors;
 import com.kingsrook.qqq.backend.core.actions.AbstractQActionFunction;
 import com.kingsrook.qqq.backend.core.actions.ActionHelper;
 import com.kingsrook.qqq.backend.core.actions.QBackendTransaction;
+import com.kingsrook.qqq.backend.core.actions.audits.DMLAuditAction;
 import com.kingsrook.qqq.backend.core.actions.automation.AutomationStatus;
 import com.kingsrook.qqq.backend.core.actions.automation.RecordAutomationStatusUpdater;
 import com.kingsrook.qqq.backend.core.actions.customizers.AbstractPostInsertCustomizer;
+import com.kingsrook.qqq.backend.core.actions.customizers.AbstractPreInsertCustomizer;
 import com.kingsrook.qqq.backend.core.actions.customizers.QCodeLoader;
 import com.kingsrook.qqq.backend.core.actions.customizers.TableCustomizers;
+import com.kingsrook.qqq.backend.core.actions.interfaces.InsertInterface;
 import com.kingsrook.qqq.backend.core.actions.tables.helpers.UniqueKeyHelper;
+import com.kingsrook.qqq.backend.core.actions.tables.helpers.ValidateRecordSecurityLockHelper;
 import com.kingsrook.qqq.backend.core.actions.values.ValueBehaviorApplier;
+import com.kingsrook.qqq.backend.core.context.QContext;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
+import com.kingsrook.qqq.backend.core.model.actions.audits.DMLAuditInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.insert.InsertInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.insert.InsertOutput;
 import com.kingsrook.qqq.backend.core.model.data.QRecord;
+import com.kingsrook.qqq.backend.core.model.metadata.fields.QFieldMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.fields.QFieldType;
+import com.kingsrook.qqq.backend.core.model.metadata.joins.JoinOn;
+import com.kingsrook.qqq.backend.core.model.metadata.joins.QJoinMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.tables.Association;
 import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.tables.UniqueKey;
+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.QBackendModuleDispatcher;
 import com.kingsrook.qqq.backend.core.modules.backend.QBackendModuleInterface;
 import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
+import com.kingsrook.qqq.backend.core.utils.ValueUtils;
+import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
 
 
 /*******************************************************************************
@@ -58,7 +74,29 @@ import org.apache.logging.log4j.Logger;
  *******************************************************************************/
 public class InsertAction extends AbstractQActionFunction<InsertInput, InsertOutput>
 {
-   private static final Logger LOG = LogManager.getLogger(InsertAction.class);
+   private static final QLogger LOG = QLogger.getLogger(InsertAction.class);
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public QRecord executeForRecord(InsertInput insertInput) throws QException
+   {
+      InsertOutput insertOutput = new InsertAction().execute(insertInput);
+      return (insertOutput.getRecords().get(0));
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public static List<QRecord> executeForRecords(InsertInput insertInput) throws QException
+   {
+      InsertOutput insertOutput = new InsertAction().execute(insertInput);
+      return (insertOutput.getRecords());
+   }
 
 
 
@@ -71,24 +109,76 @@ public class InsertAction extends AbstractQActionFunction<InsertInput, InsertOut
       ActionHelper.validateSession(insertInput);
       QTableMetaData table = insertInput.getTable();
 
-      Optional<AbstractPostInsertCustomizer> postInsertCustomizer = QCodeLoader.getTableCustomizer(AbstractPostInsertCustomizer.class, table, TableCustomizers.POST_INSERT_RECORD.getRole());
+      if(table == null)
+      {
+         throw (new QException("Error:  Undefined table: " + insertInput.getTableName()));
+      }
+
       setAutomationStatusField(insertInput);
 
-      ValueBehaviorApplier.applyFieldBehaviors(insertInput.getInstance(), table, insertInput.getRecords());
-      // todo - need to handle records with errors coming out of here...
+      //////////////////////////////////////////////////////
+      // load the backend module and its insert interface //
+      //////////////////////////////////////////////////////
+      QBackendModuleInterface qModule         = getBackendModuleInterface(insertInput);
+      InsertInterface         insertInterface = qModule.getInsertInterface();
 
-      QBackendModuleInterface qModule = getBackendModuleInterface(insertInput);
-      // todo pre-customization - just get to modify the request?
+      /////////////////////////////
+      // run standard validators //
+      /////////////////////////////
+      performValidations(insertInput, false);
 
-      setErrorsIfUniqueKeyErrors(insertInput, table);
+      ////////////////////////////////////
+      // have the backend do the insert //
+      ////////////////////////////////////
+      InsertOutput insertOutput = insertInterface.execute(insertInput);
 
-      InsertOutput insertOutput = qModule.getInsertInterface().execute(insertInput);
-      // todo post-customization - can do whatever w/ the result if you want
+      //////////////////////////////
+      // log if there were errors //
+      //////////////////////////////
+      List<String> errors = insertOutput.getRecords().stream().flatMap(r -> r.getErrors().stream().map(Object::toString)).toList();
+      if(CollectionUtils.nullSafeHasContents(errors))
+      {
+         LOG.info("Errors in insertAction", logPair("tableName", table.getName()), logPair("errorCount", errors.size()), errors.size() < 10 ? logPair("errors", errors) : logPair("first10Errors", errors.subList(0, 10)));
+      }
 
+      //////////////////////////////////////////////////
+      // insert any associations in the input records //
+      //////////////////////////////////////////////////
+      manageAssociations(table, insertOutput.getRecords(), insertInput.getTransaction());
+
+      //////////////////
+      // do the audit //
+      //////////////////
+      if(insertInput.getOmitDmlAudit())
+      {
+         LOG.debug("Requested to omit DML audit");
+      }
+      else
+      {
+         new DMLAuditAction().execute(new DMLAuditInput()
+            .withTableActionInput(insertInput)
+            .withAuditContext(insertInput.getAuditContext())
+            .withRecordList(insertOutput.getRecords()));
+      }
+
+      //////////////////////////////////////////////////////////////
+      // finally, run the post-insert customizer, if there is one //
+      //////////////////////////////////////////////////////////////
+      Optional<AbstractPostInsertCustomizer> postInsertCustomizer = QCodeLoader.getTableCustomizer(AbstractPostInsertCustomizer.class, table, TableCustomizers.POST_INSERT_RECORD.getRole());
       if(postInsertCustomizer.isPresent())
       {
-         postInsertCustomizer.get().setInsertInput(insertInput);
-         insertOutput.setRecords(postInsertCustomizer.get().apply(insertOutput.getRecords()));
+         try
+         {
+            postInsertCustomizer.get().setInsertInput(insertInput);
+            insertOutput.setRecords(postInsertCustomizer.get().apply(insertOutput.getRecords()));
+         }
+         catch(Exception e)
+         {
+            for(QRecord record : insertOutput.getRecords())
+            {
+               record.addWarning(new QWarningMessage("An error occurred after the insert: " + e.getMessage()));
+            }
+         }
       }
 
       return insertOutput;
@@ -96,6 +186,110 @@ public class InsertAction extends AbstractQActionFunction<InsertInput, InsertOut
 
 
 
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public void performValidations(InsertInput insertInput, boolean isPreview) throws QException
+   {
+      QTableMetaData table = insertInput.getTable();
+
+      ValueBehaviorApplier.applyFieldBehaviors(insertInput.getInstance(), table, insertInput.getRecords());
+      setErrorsIfUniqueKeyErrors(insertInput, table);
+
+      if(insertInput.getInputSource().shouldValidateRequiredFields())
+      {
+         validateRequiredFields(insertInput);
+      }
+
+      ValidateRecordSecurityLockHelper.validateSecurityFields(insertInput.getTable(), insertInput.getRecords(), ValidateRecordSecurityLockHelper.Action.INSERT);
+
+      ///////////////////////////////////////////////////////////////////////////
+      // after all validations, run the pre-insert customizer, if there is one //
+      ///////////////////////////////////////////////////////////////////////////
+      Optional<AbstractPreInsertCustomizer> preInsertCustomizer = QCodeLoader.getTableCustomizer(AbstractPreInsertCustomizer.class, table, TableCustomizers.PRE_INSERT_RECORD.getRole());
+      if(preInsertCustomizer.isPresent())
+      {
+         preInsertCustomizer.get().setInsertInput(insertInput);
+         preInsertCustomizer.get().setIsPreview(isPreview);
+         insertInput.setRecords(preInsertCustomizer.get().apply(insertInput.getRecords()));
+      }
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private void validateRequiredFields(InsertInput insertInput)
+   {
+      QTableMetaData table = insertInput.getTable();
+      Set<QFieldMetaData> requiredFields = table.getFields().values().stream()
+         .filter(f -> f.getIsRequired())
+         .collect(Collectors.toSet());
+
+      if(!requiredFields.isEmpty())
+      {
+         for(QRecord record : insertInput.getRecords())
+         {
+            for(QFieldMetaData requiredField : requiredFields)
+            {
+               if(record.getValue(requiredField.getName()) == null || (requiredField.getType().isStringLike() && record.getValueString(requiredField.getName()).trim().equals("")))
+               {
+                  record.addError(new BadInputStatusMessage("Missing value in required field: " + requiredField.getLabel()));
+               }
+            }
+         }
+      }
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private void manageAssociations(QTableMetaData table, List<QRecord> insertedRecords, QBackendTransaction transaction) throws QException
+   {
+      for(Association association : CollectionUtils.nonNullList(table.getAssociations()))
+      {
+         // e.g., order -> orderLine
+         QJoinMetaData join = QContext.getQInstance().getJoin(association.getJoinName()); // todo ... ever need to flip?
+         // just assume this, at least for now... if(BooleanUtils.isTrue(association.getDoInserts()))
+
+         List<QRecord> nextLevelInserts = new ArrayList<>();
+         for(QRecord record : insertedRecords)
+         {
+            if(CollectionUtils.nullSafeHasContents(record.getErrors()))
+            {
+               continue;
+            }
+
+            if(record.getAssociatedRecords() != null && record.getAssociatedRecords().containsKey(association.getName()))
+            {
+               for(QRecord associatedRecord : CollectionUtils.nonNullList(record.getAssociatedRecords().get(association.getName())))
+               {
+                  for(JoinOn joinOn : join.getJoinOns())
+                  {
+                     QFieldType type = table.getField(joinOn.getLeftField()).getType();
+                     associatedRecord.setValue(joinOn.getRightField(), ValueUtils.getValueAsFieldType(type, record.getValue(joinOn.getLeftField())));
+                  }
+                  nextLevelInserts.add(associatedRecord);
+               }
+            }
+         }
+
+         if(CollectionUtils.nullSafeHasContents(nextLevelInserts))
+         {
+            InsertInput nextLevelInsertInput = new InsertInput();
+            nextLevelInsertInput.setTransaction(transaction);
+            nextLevelInsertInput.setTableName(association.getAssociatedTableName());
+            nextLevelInsertInput.setRecords(nextLevelInserts);
+            InsertOutput nextLevelInsertOutput = new InsertAction().execute(nextLevelInsertInput);
+         }
+      }
+   }
+
+
+
    /*******************************************************************************
     **
     *******************************************************************************/
@@ -117,7 +311,7 @@ public class InsertAction extends AbstractQActionFunction<InsertInput, InsertOut
          List<UniqueKey>                         uniqueKeys   = CollectionUtils.nonNullList(table.getUniqueKeys());
          for(UniqueKey uniqueKey : uniqueKeys)
          {
-            existingKeys.put(uniqueKey, UniqueKeyHelper.getExistingKeys(insertInput, insertInput.getTransaction(), table, insertInput.getRecords(), uniqueKey));
+            existingKeys.put(uniqueKey, UniqueKeyHelper.getExistingKeys(insertInput.getTransaction(), table, insertInput.getRecords(), uniqueKey).keySet());
          }
 
          /////////////////////////////////////
@@ -136,7 +330,7 @@ public class InsertAction extends AbstractQActionFunction<InsertInput, InsertOut
                Optional<List<Serializable>> keyValues = UniqueKeyHelper.getKeyValues(table, uniqueKey, record);
                if(keyValues.isPresent() && (existingKeys.get(uniqueKey).contains(keyValues.get()) || keysInThisList.get(uniqueKey).contains(keyValues.get())))
                {
-                  record.addError("Another record already exists with this " + uniqueKey.getDescription(table));
+                  record.addError(new BadInputStatusMessage("Another record already exists with this " + uniqueKey.getDescription(table)));
                   foundDupe = true;
                   break;
                }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/tables/QueryAction.java

@@ -22,23 +22,47 @@
 package com.kingsrook.qqq.backend.core.actions.tables;
 
 
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Optional;
+import java.util.Set;
 import com.kingsrook.qqq.backend.core.actions.ActionHelper;
 import com.kingsrook.qqq.backend.core.actions.customizers.AbstractPostQueryCustomizer;
 import com.kingsrook.qqq.backend.core.actions.customizers.QCodeLoader;
 import com.kingsrook.qqq.backend.core.actions.customizers.TableCustomizers;
+import com.kingsrook.qqq.backend.core.actions.interfaces.QueryInterface;
 import com.kingsrook.qqq.backend.core.actions.reporting.BufferedRecordPipe;
+import com.kingsrook.qqq.backend.core.actions.reporting.RecordPipeBufferedWrapper;
+import com.kingsrook.qqq.backend.core.actions.tables.helpers.QueryActionCacheHelper;
+import com.kingsrook.qqq.backend.core.actions.tables.helpers.QueryStatManager;
 import com.kingsrook.qqq.backend.core.actions.values.QPossibleValueTranslator;
 import com.kingsrook.qqq.backend.core.actions.values.QValueFormatter;
+import com.kingsrook.qqq.backend.core.context.QContext;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QCriteriaOperator;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QFilterCriteria;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QQueryFilter;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryOutput;
 import com.kingsrook.qqq.backend.core.model.data.QRecord;
+import com.kingsrook.qqq.backend.core.model.metadata.QBackendMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.fields.AdornmentType;
+import com.kingsrook.qqq.backend.core.model.metadata.fields.QFieldMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.joins.JoinOn;
+import com.kingsrook.qqq.backend.core.model.metadata.joins.QJoinMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.tables.Association;
+import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
+import com.kingsrook.qqq.backend.core.model.querystats.QueryStat;
 import com.kingsrook.qqq.backend.core.modules.backend.QBackendModuleDispatcher;
 import com.kingsrook.qqq.backend.core.modules.backend.QBackendModuleInterface;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
+import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
+import com.kingsrook.qqq.backend.core.utils.ListingHash;
+import com.kingsrook.qqq.backend.core.utils.ValueUtils;
 
 
 /*******************************************************************************
@@ -47,11 +71,12 @@ import org.apache.logging.log4j.Logger;
  *******************************************************************************/
 public class QueryAction
 {
-   private static final Logger LOG = LogManager.getLogger(QueryAction.class);
+   private static final QLogger LOG = QLogger.getLogger(QueryAction.class);
 
    private Optional<AbstractPostQueryCustomizer> postQueryRecordCustomizer;
 
    private QueryInput               queryInput;
+   private QueryInterface           queryInterface;
    private QPossibleValueTranslator qPossibleValueTranslator;
 
 
@@ -63,19 +88,53 @@ public class QueryAction
    {
       ActionHelper.validateSession(queryInput);
 
-      postQueryRecordCustomizer = QCodeLoader.getTableCustomizer(AbstractPostQueryCustomizer.class, queryInput.getTable(), TableCustomizers.POST_QUERY_RECORD.getRole());
+      if(queryInput.getTableName() == null)
+      {
+         throw (new QException("Table name was not specified in query input"));
+      }
+
+      QTableMetaData table = queryInput.getTable();
+      if(table == null)
+      {
+         throw (new QException("A table named [" + queryInput.getTableName() + "] was not found in the active QInstance"));
+      }
+
+      QBackendMetaData backend = queryInput.getBackend();
+      postQueryRecordCustomizer = QCodeLoader.getTableCustomizer(AbstractPostQueryCustomizer.class, table, TableCustomizers.POST_QUERY_RECORD.getRole());
       this.queryInput = queryInput;
 
       if(queryInput.getRecordPipe() != null)
       {
          queryInput.getRecordPipe().setPostRecordActions(this::postRecordActions);
+
+         if(queryInput.getIncludeAssociations())
+         {
+            //////////////////////////////////////////////////////////////////////////////////////////
+            // if the user requested to include associations, it's important that that is buffered, //
+            // (for performance reasons), so, wrap the user's pipe with a buffer                    //
+            //////////////////////////////////////////////////////////////////////////////////////////
+            queryInput.setRecordPipe(new RecordPipeBufferedWrapper(queryInput.getRecordPipe()));
+         }
       }
 
+      QueryStat queryStat = QueryStatManager.newQueryStat(backend, table, queryInput.getFilter());
+
       QBackendModuleDispatcher qBackendModuleDispatcher = new QBackendModuleDispatcher();
-      QBackendModuleInterface  qModule                  = qBackendModuleDispatcher.getQBackendModule(queryInput.getBackend());
-      // todo pre-customization - just get to modify the request?
-      QueryOutput queryOutput = qModule.getQueryInterface().execute(queryInput);
-      // todo post-customization - can do whatever w/ the result if you want
+      QBackendModuleInterface  qModule                  = qBackendModuleDispatcher.getQBackendModule(backend);
+
+      queryInterface = qModule.getQueryInterface();
+      queryInterface.setQueryStat(queryStat);
+      QueryOutput queryOutput = queryInterface.execute(queryInput);
+
+      QueryStatManager.getInstance().add(queryStat);
+
+      ////////////////////////////
+      // handle cache use-cases //
+      ////////////////////////////
+      if(table.getCacheOf() != null)
+      {
+         new QueryActionCacheHelper().handleCaching(queryInput, queryOutput);
+      }
 
       if(queryInput.getRecordPipe() instanceof BufferedRecordPipe bufferedRecordPipe)
       {
@@ -92,12 +151,116 @@ public class QueryAction
 
 
 
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private void manageAssociations(QueryInput queryInput, List<QRecord> queryOutputRecords) throws QException
+   {
+      QTableMetaData table = queryInput.getTable();
+      for(Association association : CollectionUtils.nonNullList(table.getAssociations()))
+      {
+         if(queryInput.getAssociationNamesToInclude() == null || queryInput.getAssociationNamesToInclude().contains(association.getName()))
+         {
+            // e.g., order -> orderLine
+            QJoinMetaData join = QContext.getQInstance().getJoin(association.getJoinName()); // todo ... ever need to flip?
+            // just assume this, at least for now... if(BooleanUtils.isTrue(association.getDoInserts()))
+
+            QueryInput nextLevelQueryInput = new QueryInput();
+            nextLevelQueryInput.setTableName(association.getAssociatedTableName());
+            nextLevelQueryInput.setIncludeAssociations(true);
+            nextLevelQueryInput.setAssociationNamesToInclude(buildNextLevelAssociationNamesToInclude(association.getName(), queryInput.getAssociationNamesToInclude()));
+
+            QQueryFilter filter = new QQueryFilter();
+            nextLevelQueryInput.setFilter(filter);
+
+            ListingHash<List<Serializable>, QRecord> outerResultMap = new ListingHash<>();
+
+            if(join.getJoinOns().size() == 1)
+            {
+               JoinOn            joinOn = join.getJoinOns().get(0);
+               Set<Serializable> values = new HashSet<>();
+               for(QRecord record : queryOutputRecords)
+               {
+                  Serializable value       = record.getValue(joinOn.getLeftField());
+                  Serializable valueAsType = ValueUtils.getValueAsFieldType(table.getField(joinOn.getLeftField()).getType(), value);
+                  values.add(valueAsType);
+                  outerResultMap.add(List.of(valueAsType), record);
+               }
+               filter.addCriteria(new QFilterCriteria(joinOn.getRightField(), QCriteriaOperator.IN, new ArrayList<>(values)));
+            }
+            else
+            {
+               filter.setBooleanOperator(QQueryFilter.BooleanOperator.OR);
+
+               for(QRecord record : queryOutputRecords)
+               {
+                  QQueryFilter subFilter = new QQueryFilter();
+                  filter.addSubFilter(subFilter);
+                  List<Serializable> values = new ArrayList<>();
+                  for(JoinOn joinOn : join.getJoinOns())
+                  {
+                     Serializable value = record.getValue(joinOn.getLeftField());
+                     values.add(value);
+                     subFilter.addCriteria(new QFilterCriteria(joinOn.getRightField(), QCriteriaOperator.EQUALS, value));
+                  }
+                  outerResultMap.add(values, record);
+               }
+            }
+
+            QueryOutput nextLevelQueryOutput = new QueryAction().execute(nextLevelQueryInput);
+            for(QRecord record : nextLevelQueryOutput.getRecords())
+            {
+               List<Serializable> values = new ArrayList<>();
+               for(JoinOn joinOn : join.getJoinOns())
+               {
+                  Serializable value = record.getValue(joinOn.getRightField());
+                  values.add(value);
+               }
+
+               if(outerResultMap.containsKey(values))
+               {
+                  for(QRecord outerRecord : outerResultMap.get(values))
+                  {
+                     outerRecord.withAssociatedRecord(association.getName(), record);
+                  }
+               }
+            }
+         }
+      }
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private Collection<String> buildNextLevelAssociationNamesToInclude(String name, Collection<String> associationNamesToInclude)
+   {
+      if(associationNamesToInclude == null)
+      {
+         return (associationNamesToInclude);
+      }
+
+      Set<String> rs = new HashSet<>();
+      for(String nextLevelCandidateName : associationNamesToInclude)
+      {
+         if(nextLevelCandidateName.startsWith(name + "."))
+         {
+            rs.add(nextLevelCandidateName.replaceFirst(name + ".", ""));
+         }
+      }
+
+      return (rs);
+   }
+
+
+
    /*******************************************************************************
     ** Run the necessary actions on a list of records (which must be a mutable list - e.g.,
     ** not one created via List.of()).  This may include setting display values,
     ** translating possible values, and running post-record customizations.
     *******************************************************************************/
-   public void postRecordActions(List<QRecord> records)
+   public void postRecordActions(List<QRecord> records) throws QException
    {
       if(this.postQueryRecordCustomizer.isPresent())
       {
@@ -117,5 +280,80 @@ public class QueryAction
       {
          QValueFormatter.setDisplayValuesInRecords(queryInput.getTable(), records);
       }
+
+      if(queryInput.getIncludeAssociations())
+      {
+         manageAssociations(queryInput, records);
+      }
+
+      //////////////////////////////
+      // mask any password fields //
+      //////////////////////////////
+      if(queryInput.getShouldOmitHiddenFields() || queryInput.getShouldMaskPasswords())
+      {
+         Set<String> maskedFields = new HashSet<>();
+         Set<String> hiddenFields = new HashSet<>();
+
+         //////////////////////////////////////////////////
+         // build up sets of passwords and hidden fields //
+         //////////////////////////////////////////////////
+         Map<String, QFieldMetaData> fields = QContext.getQInstance().getTable(queryInput.getTableName()).getFields();
+         for(String fieldName : fields.keySet())
+         {
+            QFieldMetaData field = fields.get(fieldName);
+            if(queryInput.getShouldOmitHiddenFields() && field.getIsHidden())
+            {
+               hiddenFields.add(fieldName);
+            }
+            else if(queryInput.getShouldMaskPasswords() && field.getType() != null && field.getType().needsMasked() && !field.hasAdornmentType(AdornmentType.REVEAL))
+            {
+               maskedFields.add(fieldName);
+            }
+         }
+
+         /////////////////////////////////////////////////////
+         // iterate over records replacing values with mask //
+         /////////////////////////////////////////////////////
+         for(QRecord record : records)
+         {
+            /////////////////////////
+            // clear hidden fields //
+            /////////////////////////
+            for(String hiddenFieldName : hiddenFields)
+            {
+               record.removeValue(hiddenFieldName);
+            }
+
+            for(String maskedFieldName : maskedFields)
+            {
+               //////////////////////////////////////////////////////////////////////
+               // empty out the value completely first (which will remove from     //
+               // display fields as well) then update display value if flag is set //
+               //////////////////////////////////////////////////////////////////////
+               record.removeValue(maskedFieldName);
+               record.setValue(maskedFieldName, "************");
+               if(queryInput.getShouldGenerateDisplayValues())
+               {
+                  record.setDisplayValue(maskedFieldName, record.getValueString(maskedFieldName));
+               }
+            }
+         }
+      }
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public void cancel()
+   {
+      if(queryInterface == null)
+      {
+         LOG.warn("queryInterface object was null when requested to cancel");
+         return;
+      }
+
+      queryInterface.cancelAction();
    }
 }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/tables/ReplaceAction.java

@@ -0,0 +1,179 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2023.  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.tables;
+
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import com.kingsrook.qqq.backend.core.actions.AbstractQActionFunction;
+import com.kingsrook.qqq.backend.core.actions.QBackendTransaction;
+import com.kingsrook.qqq.backend.core.actions.tables.helpers.UniqueKeyHelper;
+import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
+import com.kingsrook.qqq.backend.core.model.actions.tables.delete.DeleteInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.delete.DeleteOutput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.insert.InsertInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.insert.InsertOutput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QCriteriaOperator;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QFilterCriteria;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QQueryFilter;
+import com.kingsrook.qqq.backend.core.model.actions.tables.replace.ReplaceInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.replace.ReplaceOutput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.update.UpdateInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.update.UpdateOutput;
+import com.kingsrook.qqq.backend.core.model.data.QRecord;
+import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.tables.UniqueKey;
+import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
+
+
+/*******************************************************************************
+ ** Action to do a "replace" - e.g: Update rows with unique-key values that are
+ ** already in the table; insert rows whose unique keys weren't already in the
+ ** table, and delete rows that weren't in the input (all based on a
+ ** UniqueKey that's part of the input)
+ **
+ ** Note - the filter in the ReplaceInput - its role is to limit what rows are
+ ** potentially deleted.  e.g., if you have a table that's segmented, and you're
+ ** only replacing a particular segment of it (say, for 1 client), then you pass
+ ** in a filter that finds  rows matching that segment.  See Test for example.
+ *******************************************************************************/
+public class ReplaceAction extends AbstractQActionFunction<ReplaceInput, ReplaceOutput>
+{
+   private static final QLogger LOG = QLogger.getLogger(ReplaceAction.class);
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Override
+   public ReplaceOutput execute(ReplaceInput input) throws QException
+   {
+      ReplaceOutput output = new ReplaceOutput();
+
+      QBackendTransaction transaction         = input.getTransaction();
+      boolean             weOwnTheTransaction = false;
+
+      try
+      {
+         QTableMetaData table           = input.getTable();
+         UniqueKey      uniqueKey       = input.getKey();
+         String         primaryKeyField = table.getPrimaryKeyField();
+         if(transaction == null)
+         {
+            InsertInput insertInput = new InsertInput();
+            insertInput.setTableName(input.getTableName());
+            transaction = new InsertAction().openTransaction(insertInput);
+            weOwnTheTransaction = true;
+         }
+
+         List<QRecord>      insertList        = new ArrayList<>();
+         List<QRecord>      updateList        = new ArrayList<>();
+         List<Serializable> primaryKeysToKeep = new ArrayList<>();
+
+         for(List<QRecord> page : CollectionUtils.getPages(input.getRecords(), 1000))
+         {
+            ///////////////////////////////////////////////////////////////////////////////////
+            // originally it was thought that we'd need to pass the filter in here           //
+            // but, it's been decided not to.  the filter only applies to what we can delete //
+            ///////////////////////////////////////////////////////////////////////////////////
+            Map<List<Serializable>, Serializable> existingKeys = UniqueKeyHelper.getExistingKeys(transaction, table, page, uniqueKey);
+            for(QRecord record : page)
+            {
+               Optional<List<Serializable>> keyValues = UniqueKeyHelper.getKeyValues(table, uniqueKey, record);
+               if(keyValues.isPresent())
+               {
+                  if(existingKeys.containsKey(keyValues.get()))
+                  {
+                     Serializable primaryKey = existingKeys.get(keyValues.get());
+                     record.setValue(primaryKeyField, primaryKey);
+                     updateList.add(record);
+                     primaryKeysToKeep.add(primaryKey);
+                  }
+                  else
+                  {
+                     insertList.add(record);
+                  }
+               }
+            }
+         }
+
+         InsertInput insertInput = new InsertInput();
+         insertInput.setTableName(table.getName());
+         insertInput.setRecords(insertList);
+         insertInput.setTransaction(transaction);
+         insertInput.setOmitDmlAudit(input.getOmitDmlAudit());
+         InsertOutput insertOutput = new InsertAction().execute(insertInput);
+         primaryKeysToKeep.addAll(insertOutput.getRecords().stream().map(r -> r.getValue(primaryKeyField)).toList());
+         output.setInsertOutput(insertOutput);
+
+         UpdateInput updateInput = new UpdateInput();
+         updateInput.setTableName(table.getName());
+         updateInput.setRecords(updateList);
+         updateInput.setTransaction(transaction);
+         updateInput.setOmitDmlAudit(input.getOmitDmlAudit());
+         UpdateOutput updateOutput = new UpdateAction().execute(updateInput);
+         output.setUpdateOutput(updateOutput);
+
+         QQueryFilter deleteFilter = new QQueryFilter(new QFilterCriteria(primaryKeyField, QCriteriaOperator.NOT_IN, primaryKeysToKeep));
+         if(input.getFilter() != null)
+         {
+            deleteFilter.addSubFilter(input.getFilter());
+         }
+
+         DeleteInput deleteInput = new DeleteInput();
+         deleteInput.setTableName(table.getName());
+         deleteInput.setQueryFilter(deleteFilter);
+         deleteInput.setTransaction(transaction);
+         deleteInput.setOmitDmlAudit(input.getOmitDmlAudit());
+         DeleteOutput deleteOutput = new DeleteAction().execute(deleteInput);
+         output.setDeleteOutput(deleteOutput);
+
+         if(weOwnTheTransaction)
+         {
+            transaction.commit();
+         }
+
+         return (output);
+      }
+      catch(Exception e)
+      {
+         if(weOwnTheTransaction)
+         {
+            LOG.warn("Caught top-level ReplaceAction exception - rolling back exception", e);
+            transaction.rollback();
+         }
+         throw (new QException("Error executing replace action", e));
+      }
+      finally
+      {
+         if(weOwnTheTransaction)
+         {
+            transaction.close();
+         }
+      }
+   }
+}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/tables/UpdateAction.java

@@ -22,15 +22,57 @@
 package com.kingsrook.qqq.backend.core.actions.tables;
 
 
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Collectors;
 import com.kingsrook.qqq.backend.core.actions.ActionHelper;
+import com.kingsrook.qqq.backend.core.actions.audits.DMLAuditAction;
 import com.kingsrook.qqq.backend.core.actions.automation.AutomationStatus;
 import com.kingsrook.qqq.backend.core.actions.automation.RecordAutomationStatusUpdater;
+import com.kingsrook.qqq.backend.core.actions.customizers.AbstractPostUpdateCustomizer;
+import com.kingsrook.qqq.backend.core.actions.customizers.AbstractPreUpdateCustomizer;
+import com.kingsrook.qqq.backend.core.actions.customizers.QCodeLoader;
+import com.kingsrook.qqq.backend.core.actions.customizers.TableCustomizers;
+import com.kingsrook.qqq.backend.core.actions.interfaces.UpdateInterface;
+import com.kingsrook.qqq.backend.core.actions.tables.helpers.ValidateRecordSecurityLockHelper;
 import com.kingsrook.qqq.backend.core.actions.values.ValueBehaviorApplier;
+import com.kingsrook.qqq.backend.core.context.QContext;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
+import com.kingsrook.qqq.backend.core.model.actions.audits.DMLAuditInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.delete.DeleteInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.delete.DeleteOutput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.insert.InsertInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.insert.InsertOutput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QCriteriaOperator;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QFilterCriteria;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QQueryFilter;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryOutput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.update.UpdateInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.update.UpdateOutput;
+import com.kingsrook.qqq.backend.core.model.data.QRecord;
+import com.kingsrook.qqq.backend.core.model.metadata.fields.QFieldMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.fields.QFieldType;
+import com.kingsrook.qqq.backend.core.model.metadata.joins.JoinOn;
+import com.kingsrook.qqq.backend.core.model.metadata.joins.QJoinMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.security.RecordSecurityLock;
+import com.kingsrook.qqq.backend.core.model.metadata.security.RecordSecurityLockFilters;
+import com.kingsrook.qqq.backend.core.model.metadata.tables.Association;
+import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
+import com.kingsrook.qqq.backend.core.model.statusmessages.BadInputStatusMessage;
+import com.kingsrook.qqq.backend.core.model.statusmessages.NotFoundStatusMessage;
+import com.kingsrook.qqq.backend.core.model.statusmessages.QWarningMessage;
 import com.kingsrook.qqq.backend.core.modules.backend.QBackendModuleDispatcher;
 import com.kingsrook.qqq.backend.core.modules.backend.QBackendModuleInterface;
+import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
+import com.kingsrook.qqq.backend.core.utils.ValueUtils;
+import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
 
 
 /*******************************************************************************
@@ -39,6 +81,32 @@ import com.kingsrook.qqq.backend.core.modules.backend.QBackendModuleInterface;
  *******************************************************************************/
 public class UpdateAction
 {
+   private static final QLogger LOG = QLogger.getLogger(UpdateAction.class);
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public QRecord executeForRecord(UpdateInput updateInput) throws QException
+   {
+      UpdateOutput updateOutput = new UpdateAction().execute(updateInput);
+      return (updateOutput.getRecords().get(0));
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public static List<QRecord> executeForRecords(UpdateInput updateInput) throws QException
+   {
+      UpdateOutput updateOutput = new UpdateAction().execute(updateInput);
+      return (updateOutput.getRecords());
+   }
+
+
+
    /*******************************************************************************
     **
     *******************************************************************************/
@@ -47,15 +115,414 @@ public class UpdateAction
       ActionHelper.validateSession(updateInput);
       setAutomationStatusField(updateInput);
 
-      ValueBehaviorApplier.applyFieldBehaviors(updateInput.getInstance(), updateInput.getTable(), updateInput.getRecords());
-      // todo - need to handle records with errors coming out of here...
+      QTableMetaData table = updateInput.getTable();
 
+      //////////////////////////////////////////////////////
+      // load the backend module and its update interface //
+      //////////////////////////////////////////////////////
       QBackendModuleDispatcher qBackendModuleDispatcher = new QBackendModuleDispatcher();
       QBackendModuleInterface  qModule                  = qBackendModuleDispatcher.getQBackendModule(updateInput.getBackend());
-      // todo pre-customization - just get to modify the request?
-      UpdateOutput updateResult = qModule.getUpdateInterface().execute(updateInput);
-      // todo post-customization - can do whatever w/ the result if you want
-      return updateResult;
+      UpdateInterface          updateInterface          = qModule.getUpdateInterface();
+
+      ////////////////////////////////////////////////////////////////////////////////
+      // fetch the old list of records (if the backend supports it), for audits,    //
+      // for "not-found detection", and for the pre-action to use (if there is one) //
+      ////////////////////////////////////////////////////////////////////////////////
+      Optional<List<QRecord>> oldRecordList = fetchOldRecords(updateInput, updateInterface);
+
+      performValidations(updateInput, oldRecordList, false);
+
+      ////////////////////////////////////
+      // have the backend do the update //
+      ////////////////////////////////////
+      UpdateOutput updateOutput = updateInterface.execute(updateInput);
+
+      //////////////////////////////
+      // log if there were errors //
+      //////////////////////////////
+      List<String> errors = updateOutput.getRecords().stream().flatMap(r -> r.getErrors().stream().map(Object::toString)).toList();
+      if(CollectionUtils.nullSafeHasContents(errors))
+      {
+         LOG.info("Errors in updateAction", logPair("tableName", updateInput.getTableName()), logPair("errorCount", errors.size()), errors.size() < 10 ? logPair("errors", errors) : logPair("first10Errors", errors.subList(0, 10)));
+      }
+
+      /////////////////////////////////////////////////////////////////////////////////////
+      // update (inserting and deleting as needed) any associations in the input records //
+      /////////////////////////////////////////////////////////////////////////////////////
+      manageAssociations(updateInput);
+
+      //////////////////
+      // do the audit //
+      //////////////////
+      if(updateInput.getOmitDmlAudit())
+      {
+         LOG.debug("Requested to omit DML audit");
+      }
+      else
+      {
+         DMLAuditInput dmlAuditInput = new DMLAuditInput()
+            .withTableActionInput(updateInput)
+            .withRecordList(updateOutput.getRecords())
+            .withAuditContext(updateInput.getAuditContext());
+         oldRecordList.ifPresent(l -> dmlAuditInput.setOldRecordList(l));
+         new DMLAuditAction().execute(dmlAuditInput);
+      }
+
+      //////////////////////////////////////////////////////////////
+      // finally, run the post-update customizer, if there is one //
+      //////////////////////////////////////////////////////////////
+      Optional<AbstractPostUpdateCustomizer> postUpdateCustomizer = QCodeLoader.getTableCustomizer(AbstractPostUpdateCustomizer.class, table, TableCustomizers.POST_UPDATE_RECORD.getRole());
+      if(postUpdateCustomizer.isPresent())
+      {
+         try
+         {
+            postUpdateCustomizer.get().setUpdateInput(updateInput);
+            oldRecordList.ifPresent(l -> postUpdateCustomizer.get().setOldRecordList(l));
+            updateOutput.setRecords(postUpdateCustomizer.get().apply(updateOutput.getRecords()));
+         }
+         catch(Exception e)
+         {
+            for(QRecord record : updateOutput.getRecords())
+            {
+               record.addWarning(new QWarningMessage("An error occurred after the update: " + e.getMessage()));
+            }
+         }
+      }
+
+      return updateOutput;
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public void performValidations(UpdateInput updateInput, Optional<List<QRecord>> oldRecordList, boolean isPreview) throws QException
+   {
+      QTableMetaData table = updateInput.getTable();
+
+      /////////////////////////////
+      // run standard validators //
+      /////////////////////////////
+      ValueBehaviorApplier.applyFieldBehaviors(updateInput.getInstance(), table, updateInput.getRecords());
+      validatePrimaryKeysAreGiven(updateInput);
+
+      if(oldRecordList.isPresent())
+      {
+         validateRecordsExistAndCanBeAccessed(updateInput, oldRecordList.get());
+      }
+      else
+      {
+         ValidateRecordSecurityLockHelper.validateSecurityFields(table, updateInput.getRecords(), ValidateRecordSecurityLockHelper.Action.UPDATE);
+      }
+
+      if(updateInput.getInputSource().shouldValidateRequiredFields())
+      {
+         validateRequiredFields(updateInput);
+      }
+
+      ///////////////////////////////////////////////////////////////////////////
+      // after all validations, run the pre-update customizer, if there is one //
+      ///////////////////////////////////////////////////////////////////////////
+      Optional<AbstractPreUpdateCustomizer> preUpdateCustomizer = QCodeLoader.getTableCustomizer(AbstractPreUpdateCustomizer.class, table, TableCustomizers.PRE_UPDATE_RECORD.getRole());
+      if(preUpdateCustomizer.isPresent())
+      {
+         preUpdateCustomizer.get().setUpdateInput(updateInput);
+         preUpdateCustomizer.get().setIsPreview(isPreview);
+         oldRecordList.ifPresent(l -> preUpdateCustomizer.get().setOldRecordList(l));
+         updateInput.setRecords(preUpdateCustomizer.get().apply(updateInput.getRecords()));
+      }
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private Optional<List<QRecord>> fetchOldRecords(UpdateInput updateInput, UpdateInterface updateInterface) throws QException
+   {
+      if(updateInterface.supportsPreFetchQuery())
+      {
+         String             primaryKeyField   = updateInput.getTable().getPrimaryKeyField();
+         List<Serializable> pkeysBeingUpdated = CollectionUtils.nonNullList(updateInput.getRecords()).stream().map(r -> r.getValue(primaryKeyField)).toList();
+
+         QueryInput queryInput = new QueryInput();
+         queryInput.setTransaction(updateInput.getTransaction());
+         queryInput.setTableName(updateInput.getTableName());
+         queryInput.setFilter(new QQueryFilter(new QFilterCriteria(primaryKeyField, QCriteriaOperator.IN, pkeysBeingUpdated)));
+         // todo - need a limit?  what if too many??
+         QueryOutput queryOutput = new QueryAction().execute(queryInput);
+
+         return (Optional.of(queryOutput.getRecords()));
+      }
+
+      return (Optional.empty());
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private void validatePrimaryKeysAreGiven(UpdateInput updateInput)
+   {
+      QTableMetaData table = updateInput.getTable();
+      for(QRecord record : CollectionUtils.nonNullList(updateInput.getRecords()))
+      {
+         ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+         // to update a record, we must have its primary key value - so - check - if it's missing, mark it as an error //
+         ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+         if(record.getValue(table.getPrimaryKeyField()) == null)
+         {
+            record.addError(new BadInputStatusMessage("Missing value in primary key field"));
+         }
+      }
+   }
+
+
+
+   /*******************************************************************************
+    ** Note - the "can be accessed" part of this method name - it implies that
+    ** records that you can't see because of security - that they won't be found
+    ** by the query here, so it's the same to you as if they don't exist at all!
+    *******************************************************************************/
+   private void validateRecordsExistAndCanBeAccessed(UpdateInput updateInput, List<QRecord> oldRecordList) throws QException
+   {
+      QTableMetaData table           = updateInput.getTable();
+      QFieldMetaData primaryKeyField = table.getField(table.getPrimaryKeyField());
+
+      List<RecordSecurityLock> onlyWriteLocks = RecordSecurityLockFilters.filterForOnlyWriteLocks(CollectionUtils.nonNullList(table.getRecordSecurityLocks()));
+
+      for(List<QRecord> page : CollectionUtils.getPages(updateInput.getRecords(), 1000))
+      {
+         List<Serializable> primaryKeysToLookup = new ArrayList<>();
+         for(QRecord record : page)
+         {
+            Serializable primaryKeyValue = record.getValue(table.getPrimaryKeyField());
+            if(primaryKeyValue != null)
+            {
+               primaryKeysToLookup.add(primaryKeyValue);
+            }
+         }
+
+         Map<Serializable, QRecord> lookedUpRecords = new HashMap<>();
+         if(CollectionUtils.nullSafeHasContents(oldRecordList))
+         {
+            for(QRecord record : oldRecordList)
+            {
+               lookedUpRecords.put(record.getValue(table.getPrimaryKeyField()), record);
+            }
+         }
+         else if(!primaryKeysToLookup.isEmpty())
+         {
+            QueryInput queryInput = new QueryInput();
+            queryInput.setTransaction(updateInput.getTransaction());
+            queryInput.setTableName(table.getName());
+            queryInput.setFilter(new QQueryFilter(new QFilterCriteria(table.getPrimaryKeyField(), QCriteriaOperator.IN, primaryKeysToLookup)));
+            QueryOutput queryOutput = new QueryAction().execute(queryInput);
+            for(QRecord record : queryOutput.getRecords())
+            {
+               lookedUpRecords.put(record.getValue(table.getPrimaryKeyField()), record);
+            }
+         }
+
+         ValidateRecordSecurityLockHelper.validateSecurityFields(table, updateInput.getRecords(), ValidateRecordSecurityLockHelper.Action.UPDATE);
+
+         for(QRecord record : page)
+         {
+            Serializable value = ValueUtils.getValueAsFieldType(primaryKeyField.getType(), record.getValue(table.getPrimaryKeyField()));
+            if(value == null)
+            {
+               continue;
+            }
+
+            if(!lookedUpRecords.containsKey(value))
+            {
+               record.addError(new NotFoundStatusMessage("No record was found to update for " + primaryKeyField.getLabel() + " = " + value));
+            }
+            else
+            {
+               ///////////////////////////////////////////////////////////////////////////////////////////
+               // if the table has any write-only locks, validate their values here, on the old-records //
+               ///////////////////////////////////////////////////////////////////////////////////////////
+               for(RecordSecurityLock lock : onlyWriteLocks)
+               {
+                  QRecord      oldRecord = lookedUpRecords.get(value);
+                  QFieldType   fieldType = table.getField(lock.getFieldName()).getType();
+                  Serializable lockValue = ValueUtils.getValueAsFieldType(fieldType, oldRecord.getValue(lock.getFieldName()));
+                  ValidateRecordSecurityLockHelper.validateRecordSecurityValue(table, record, lock, lockValue, fieldType, ValidateRecordSecurityLockHelper.Action.UPDATE);
+               }
+            }
+         }
+      }
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private void validateRequiredFields(UpdateInput updateInput)
+   {
+      QTableMetaData table = updateInput.getTable();
+      Set<QFieldMetaData> requiredFields = table.getFields().values().stream()
+         .filter(f -> f.getIsRequired())
+         .collect(Collectors.toSet());
+
+      if(!requiredFields.isEmpty())
+      {
+         for(QRecord record : CollectionUtils.nonNullList(updateInput.getRecords()))
+         {
+            for(QFieldMetaData requiredField : requiredFields)
+            {
+               /////////////////////////////////////////////////////////////////////////////////////////////
+               // only consider fields that were set in the record to be updated (e.g., "patch" semantic) //
+               /////////////////////////////////////////////////////////////////////////////////////////////
+               if(record.getValues().containsKey(requiredField.getName()))
+               {
+                  if(record.getValue(requiredField.getName()) == null || record.getValueString(requiredField.getName()).trim().equals(""))
+                  {
+                     record.addError(new BadInputStatusMessage("Missing value in required field: " + requiredField.getLabel()));
+                  }
+               }
+            }
+         }
+      }
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private void manageAssociations(UpdateInput updateInput) throws QException
+   {
+      QTableMetaData table = updateInput.getTable();
+      for(Association association : CollectionUtils.nonNullList(table.getAssociations()))
+      {
+         // e.g., order -> orderLine
+         QTableMetaData associatedTable = QContext.getQInstance().getTable(association.getAssociatedTableName());
+         QJoinMetaData  join            = QContext.getQInstance().getJoin(association.getJoinName()); // todo ... ever need to flip?
+         // just assume this, at least for now... if(BooleanUtils.isTrue(association.getDoInserts()))
+
+         for(List<QRecord> page : CollectionUtils.getPages(updateInput.getRecords(), 500))
+         {
+            List<QRecord> nextLevelUpdates  = new ArrayList<>();
+            List<QRecord> nextLevelInserts  = new ArrayList<>();
+            QQueryFilter  findDeletesFilter = new QQueryFilter().withBooleanOperator(QQueryFilter.BooleanOperator.OR);
+            boolean       lookForDeletes    = false;
+
+            //////////////////////////////////////////////////////
+            // for each updated record, look at as associations //
+            //////////////////////////////////////////////////////
+            for(QRecord record : page)
+            {
+               if(CollectionUtils.nullSafeHasContents(record.getErrors()))
+               {
+                  continue;
+               }
+
+               if(record.getAssociatedRecords() != null && record.getAssociatedRecords().containsKey(association.getName()))
+               {
+                  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                  // build a sub-query to find the children of this record - and we'll exclude (below) any whose ids are given //
+                  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                  QQueryFilter subFilter = new QQueryFilter();
+                  findDeletesFilter.addSubFilter(subFilter);
+                  lookForDeletes = true;
+                  List<Serializable> idsBeingUpdated = new ArrayList<>();
+                  for(JoinOn joinOn : join.getJoinOns())
+                  {
+                     subFilter.addCriteria(new QFilterCriteria(joinOn.getRightField(), QCriteriaOperator.EQUALS, record.getValue(joinOn.getLeftField())));
+                  }
+
+                  //////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                  // for any associated records present here, figure out if they're being inserted (no primaryKey) or updated //
+                  //////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                  for(QRecord associatedRecord : CollectionUtils.nonNullList(record.getAssociatedRecords().get(association.getName())))
+                  {
+                     Serializable associatedId = associatedRecord.getValue(associatedTable.getPrimaryKeyField());
+                     if(associatedId == null)
+                     {
+                        //////////////////////////////////////////////////////////////////////////////////////////////////////////
+                        // if inserting, add to the inserts list, and propagate values from the header record down to the child //
+                        //////////////////////////////////////////////////////////////////////////////////////////////////////////
+                        for(JoinOn joinOn : join.getJoinOns())
+                        {
+                           QFieldType type = table.getField(joinOn.getLeftField()).getType();
+                           associatedRecord.setValue(joinOn.getRightField(), ValueUtils.getValueAsFieldType(type, record.getValue(joinOn.getLeftField())));
+                        }
+                        nextLevelInserts.add(associatedRecord);
+                     }
+                     else
+                     {
+                        ///////////////////////////////////////////////////////////////////////////////
+                        // if updating, add to the updates list, and add the id as one to not delete //
+                        ///////////////////////////////////////////////////////////////////////////////
+                        idsBeingUpdated.add(associatedId);
+                        nextLevelUpdates.add(associatedRecord);
+
+                        /////////////////////////////////////////////////////////////////////////////////////////////////
+                        // make sure the child record being updated has its join fields populated (same as an insert). //
+                        // this will make the next update action much happier                                          //
+                        /////////////////////////////////////////////////////////////////////////////////////////////////
+                        for(JoinOn joinOn : join.getJoinOns())
+                        {
+                           QFieldType type = table.getField(joinOn.getLeftField()).getType();
+                           associatedRecord.setValue(joinOn.getRightField(), ValueUtils.getValueAsFieldType(type, record.getValue(joinOn.getLeftField())));
+                        }
+                     }
+                  }
+
+                  if(!idsBeingUpdated.isEmpty())
+                  {
+                     ///////////////////////////////////////////////////////////////////////////////
+                     // if any records are being updated, add them to the query to NOT be deleted //
+                     ///////////////////////////////////////////////////////////////////////////////
+                     subFilter.addCriteria(new QFilterCriteria(associatedTable.getPrimaryKeyField(), QCriteriaOperator.NOT_IN, idsBeingUpdated));
+                  }
+               }
+            }
+
+            if(lookForDeletes)
+            {
+               QueryInput queryInput = new QueryInput();
+               queryInput.setTransaction(updateInput.getTransaction());
+               queryInput.setTableName(associatedTable.getName());
+               queryInput.setFilter(findDeletesFilter);
+               QueryOutput queryOutput = new QueryAction().execute(queryInput);
+               if(!queryOutput.getRecords().isEmpty())
+               {
+                  LOG.debug("Deleting associatedRecords", logPair("associatedTable", associatedTable.getName()), logPair("noOfRecords", queryOutput.getRecords().size()));
+                  DeleteInput deleteInput = new DeleteInput();
+                  deleteInput.setTransaction(updateInput.getTransaction());
+                  deleteInput.setTableName(association.getAssociatedTableName());
+                  deleteInput.setPrimaryKeys(queryOutput.getRecords().stream().map(r -> r.getValue(associatedTable.getPrimaryKeyField())).collect(Collectors.toList()));
+                  DeleteOutput deleteOutput = new DeleteAction().execute(deleteInput);
+               }
+            }
+
+            if(CollectionUtils.nullSafeHasContents(nextLevelUpdates))
+            {
+               LOG.debug("Updating associatedRecords", logPair("associatedTable", associatedTable.getName()), logPair("noOfRecords", nextLevelUpdates.size()));
+               UpdateInput nextLevelUpdateInput = new UpdateInput();
+               nextLevelUpdateInput.setTransaction(updateInput.getTransaction());
+               nextLevelUpdateInput.setTableName(association.getAssociatedTableName());
+               nextLevelUpdateInput.setRecords(nextLevelUpdates);
+               UpdateOutput nextLevelUpdateOutput = new UpdateAction().execute(nextLevelUpdateInput);
+            }
+
+            if(CollectionUtils.nullSafeHasContents(nextLevelInserts))
+            {
+               LOG.debug("Inserting associatedRecords", logPair("associatedTable", associatedTable.getName()), logPair("noOfRecords", nextLevelUpdates.size()));
+               InsertInput nextLevelInsertInput = new InsertInput();
+               nextLevelInsertInput.setTransaction(updateInput.getTransaction());
+               nextLevelInsertInput.setTableName(association.getAssociatedTableName());
+               nextLevelInsertInput.setRecords(nextLevelInserts);
+               InsertOutput nextLevelInsertOutput = new InsertAction().execute(nextLevelInsertInput);
+            }
+         }
+      }
    }
 
 

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/tables/helpers/ActionTimeoutHelper.java

@@ -0,0 +1,109 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2023.  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.tables.helpers;
+
+
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+
+
+/*******************************************************************************
+ ** For actions that may want to set a timeout, and cancel themselves if they run
+ ** too long - this class helps.
+ **
+ ** Construct with the timeout (delay & timeUnit), and a runnable that takes care
+ ** of doing the cancel (e.g., cancelling a JDBC statement).
+ **
+ ** Call start() to make a future get scheduled (note, if delay was null or <= 0,
+ ** then it doesn't get scheduled at all).
+ **
+ ** Call cancel() if the action got far enough/completed, to cancel the future.
+ **
+ ** You can check didTimeout (getDidTimeout()) to know if the timeout did occur.
+ *******************************************************************************/
+public class ActionTimeoutHelper
+{
+   private final Integer            delay;
+   private final TimeUnit           timeUnit;
+   private final Runnable           runnable;
+   private       ScheduledFuture<?> future;
+
+   private boolean didTimeout = false;
+
+
+
+   /*******************************************************************************
+    ** Constructor
+    **
+    *******************************************************************************/
+   public ActionTimeoutHelper(Integer delay, TimeUnit timeUnit, Runnable runnable)
+   {
+      this.delay = delay;
+      this.timeUnit = timeUnit;
+      this.runnable = runnable;
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public void start()
+   {
+      if(delay == null || delay <= 0)
+      {
+         return;
+      }
+
+      future = Executors.newSingleThreadScheduledExecutor().schedule(() ->
+      {
+         didTimeout = true;
+         runnable.run();
+      }, delay, timeUnit);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public void cancel()
+   {
+      if(future != null)
+      {
+         future.cancel(true);
+      }
+   }
+
+
+
+   /*******************************************************************************
+    ** Getter for didTimeout
+    **
+    *******************************************************************************/
+   public boolean getDidTimeout()
+   {
+      return didTimeout;
+   }
+
+}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/tables/helpers/CacheUtils.java

@@ -0,0 +1,104 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2023.  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.tables.helpers;
+
+
+import java.time.Instant;
+import com.kingsrook.qqq.backend.core.logging.LogPair;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QQueryFilter;
+import com.kingsrook.qqq.backend.core.model.data.QRecord;
+import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.tables.cache.CacheUseCase;
+import com.kingsrook.qqq.backend.core.modules.backend.implementations.utils.BackendQueryFilterUtils;
+import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
+import com.kingsrook.qqq.backend.core.utils.StringUtils;
+
+
+/*******************************************************************************
+ **
+ *******************************************************************************/
+public class CacheUtils
+{
+   private static final QLogger LOG = QLogger.getLogger(CacheUtils.class);
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   static QRecord mapSourceRecordToCacheRecord(QTableMetaData table, QRecord recordFromSource, CacheUseCase cacheUseCase)
+   {
+      QRecord cacheRecord = new QRecord(recordFromSource);
+
+      //////////////////////////////////////////////////////////////////////////////////////////////
+      // make sure every value in the qRecord is set, because we will possibly be doing an update //
+      // on this record and want to null out any fields not set, not leave them populated         //
+      //////////////////////////////////////////////////////////////////////////////////////////////
+      for(String fieldName : table.getFields().keySet())
+      {
+         if(fieldName.equals(table.getPrimaryKeyField()))
+         {
+            if(!cacheUseCase.getDoCopySourcePrimaryKeyToCache())
+            {
+               cacheRecord.removeValue(fieldName);
+            }
+         }
+         else if(!cacheRecord.getValues().containsKey(fieldName))
+         {
+            cacheRecord.setValue(fieldName, null);
+         }
+      }
+
+      if(StringUtils.hasContent(table.getCacheOf().getCachedDateFieldName()))
+      {
+         cacheRecord.setValue(table.getCacheOf().getCachedDateFieldName(), Instant.now());
+      }
+      return (cacheRecord);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   static boolean shouldCacheRecord(QTableMetaData table, QRecord recordToCache)
+   {
+      boolean shouldCacheRecord = true;
+      recordMatchExclusionLoop:
+      for(CacheUseCase useCase : CollectionUtils.nonNullList(table.getCacheOf().getUseCases()))
+      {
+         for(QQueryFilter filter : CollectionUtils.nonNullList(useCase.getExcludeRecordsMatching()))
+         {
+            if(BackendQueryFilterUtils.doesRecordMatch(filter, recordToCache))
+            {
+               LOG.info("Not caching record because it matches a use case's filter exclusion", new LogPair("record", recordToCache), new LogPair("filter", filter));
+               shouldCacheRecord = false;
+               break recordMatchExclusionLoop;
+            }
+         }
+      }
+
+      return (shouldCacheRecord);
+   }
+
+}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/tables/helpers/GetActionCacheHelper.java

@@ -0,0 +1,241 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2023.  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.tables.helpers;
+
+
+import com.kingsrook.qqq.backend.core.actions.tables.GetAction;
+import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
+import com.kingsrook.qqq.backend.core.model.actions.tables.get.GetInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.get.GetOutput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryOutput;
+import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
+
+
+/*******************************************************************************
+ **
+ *******************************************************************************/
+public class GetActionCacheHelper
+{
+   private static final QLogger LOG = QLogger.getLogger(GetActionCacheHelper.class);
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public void handleCaching(GetInput getInput, GetOutput getOutput) throws QException
+   {
+      ///////////////////////////////////////////////////////
+      // copy Get input & output into Query input & output //
+      ///////////////////////////////////////////////////////
+      QueryInput queryInput = GetAction.convertGetInputToQueryInput(getInput);
+
+      QueryOutput queryOutput = new QueryOutput(queryInput);
+      if(getOutput.getRecord() != null)
+      {
+         queryOutput.addRecord(getOutput.getRecord());
+      }
+
+      ////////////////////////////////////
+      // run the QueryActionCacheHelper //
+      ////////////////////////////////////
+      new QueryActionCacheHelper().handleCaching(queryInput, queryOutput);
+
+      ///////////////////////////////////
+      // set result back in get output //
+      ///////////////////////////////////
+      if(CollectionUtils.nullSafeHasContents(queryOutput.getRecords()))
+      {
+         getOutput.setRecord(queryOutput.getRecords().get(0));
+      }
+      else
+      {
+         getOutput.setRecord(null);
+      }
+   }
+
+   /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+   // In July 2023, initial caching was added in QueryAction.                                                                             //
+   // at this time, it felt wrong to essentially duplicate this code between Get & Query - as Get is a simplified use-case of Query.      //
+   // so - we'll keep this code here, as a potential quick/easy fallback - but - see above - where we use QueryActionCacheHelper instead. //
+   /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+   /*
+   public void handleCaching(GetInput getInput, GetOutput getOutput) throws QException
+   {
+      if(getOutput.getRecord() == null)
+      {
+         ///////////////////////////////////////////////////////////////////////
+         // if the record wasn't found, see if we should look in cache-source //
+         ///////////////////////////////////////////////////////////////////////
+         QRecord recordFromSource = tryToGetFromCacheSource(getInput);
+         if(recordFromSource != null)
+         {
+            /////////////////////////////////////////////////////////////////////////////////////////////////
+            // good, we found a record from the source, make sure we should cache it, and if so, do it now //
+            // note, we always return the record from the source, even if we don't cache it.               //
+            /////////////////////////////////////////////////////////////////////////////////////////////////
+            QTableMetaData table         = getInput.getTable();
+            QRecord        recordToCache = CacheUtils.mapSourceRecordToCacheRecord(table, recordFromSource);
+            getOutput.setRecord(recordToCache);
+
+            boolean shouldCacheRecord = CacheUtils.shouldCacheRecord(table, recordToCache);
+            if(shouldCacheRecord)
+            {
+               InsertInput insertInput = new InsertInput();
+               insertInput.setTableName(getInput.getTableName());
+               insertInput.setRecords(List.of(recordToCache));
+               InsertOutput insertOutput = new InsertAction().execute(insertInput);
+
+               /////////////////////////////////////////////////////////////////////////////////////////////
+               // update the result record from the insert (e.g., so we get its id, just in case we care) //
+               /////////////////////////////////////////////////////////////////////////////////////////////
+               getOutput.setRecord(insertOutput.getRecords().get(0));
+            }
+         }
+      }
+      else
+      {
+         /////////////////////////////////////////////////////////////////////////////////
+         // if the record was found, but it's too old, maybe re-fetch from cache source //
+         /////////////////////////////////////////////////////////////////////////////////
+         refreshCacheIfExpired(getInput, getOutput);
+      }
+   }
+
+
+
+   private QRecord tryToGetFromCacheSource(GetInput getInput) throws QException
+   {
+      QRecord        recordFromSource = null;
+      QTableMetaData table            = getInput.getTable();
+
+      for(CacheUseCase cacheUseCase : CollectionUtils.nonNullList(table.getCacheOf().getUseCases()))
+      {
+         if(CacheUseCase.Type.UNIQUE_KEY_TO_UNIQUE_KEY.equals(cacheUseCase.getType()) && getInput.getUniqueKey() != null)
+         {
+            recordFromSource = getFromCachedSourceForUniqueKeyToUniqueKey(getInput, table.getCacheOf().getSourceTable());
+            break;
+         }
+         else
+         {
+            // todo!!
+            throw new NotImplementedException("Not-yet-implemented cache use case type: " + cacheUseCase.getType());
+         }
+      }
+
+      return (recordFromSource);
+   }
+
+
+
+   private void refreshCacheIfExpired(GetInput getInput, GetOutput getOutput) throws QException
+   {
+      QTableMetaData table             = getInput.getTable();
+      Integer        expirationSeconds = table.getCacheOf().getExpirationSeconds();
+      if(expirationSeconds != null)
+      {
+         QRecord cachedRecord = getOutput.getRecord();
+         Instant cachedDate   = cachedRecord.getValueInstant(table.getCacheOf().getCachedDateFieldName());
+         if(cachedDate == null || cachedDate.isBefore(Instant.now().minus(expirationSeconds, ChronoUnit.SECONDS)))
+         {
+            //////////////////////////////////////////////////////////////////////////
+            // keep the serial key from the old record in case we need to delete it //
+            //////////////////////////////////////////////////////////////////////////
+            Serializable oldRecordPrimaryKey = cachedRecord.getValue(table.getPrimaryKeyField());
+            boolean      shouldDeleteCachedRecord;
+
+            ///////////////////////////////////////////
+            // fetch record from original source now //
+            ///////////////////////////////////////////
+            QRecord recordFromSource = tryToGetFromCacheSource(getInput);
+            if(recordFromSource != null)
+            {
+               ///////////////////////////////////////////////////////////////////
+               // if the record was found in the source, put it into the output //
+               // object so returned back to caller                             //
+               ///////////////////////////////////////////////////////////////////
+               QRecord recordToCache = CacheUtils.mapSourceRecordToCacheRecord(table, recordFromSource);
+               recordToCache.setValue(table.getPrimaryKeyField(), cachedRecord.getValue(table.getPrimaryKeyField()));
+               getOutput.setRecord(recordToCache);
+
+               //////////////////////////////////////////////////////////////////////////////////////////////////////////////
+               // if the record should be cached, update the cache record - else set the flag to delete the cached record. //
+               //////////////////////////////////////////////////////////////////////////////////////////////////////////////
+               if(CacheUtils.shouldCacheRecord(table, recordToCache))
+               {
+                  UpdateInput updateInput = new UpdateInput();
+                  updateInput.setTableName(getInput.getTableName());
+                  updateInput.setRecords(List.of(recordToCache));
+                  UpdateOutput updateOutput = new UpdateAction().execute(updateInput);
+                  getOutput.setRecord(updateOutput.getRecords().get(0));
+                  shouldDeleteCachedRecord = false;
+               }
+               else
+               {
+                  shouldDeleteCachedRecord = true;
+               }
+            }
+            else
+            {
+               ///////////////////////////////////////////////////////////////////////////////////////
+               // if we did not get a record back from the source, empty out the getOutput's record //
+               // and set the flag to delete the cached record                                      //
+               ///////////////////////////////////////////////////////////////////////////////////////
+               getOutput.setRecord(null);
+               shouldDeleteCachedRecord = true;
+            }
+
+            if(shouldDeleteCachedRecord)
+            {
+               //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+               // if the record is no longer in the source (or it was in the source, but failed the should-cache check), then remove it from the cache //
+               //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+               DeleteInput deleteInput = new DeleteInput();
+               deleteInput.setTableName(getInput.getTableName());
+               deleteInput.setPrimaryKeys(List.of(oldRecordPrimaryKey));
+               new DeleteAction().execute(deleteInput);
+            }
+         }
+      }
+   }
+
+
+
+   private QRecord getFromCachedSourceForUniqueKeyToUniqueKey(GetInput getInput, String sourceTableName) throws QException
+   {
+      /////////////////////////////////////////////////////
+      // do a Get on the source table, by the unique key //
+      /////////////////////////////////////////////////////
+      GetInput sourceGetInput = new GetInput();
+      sourceGetInput.setTableName(sourceTableName);
+      sourceGetInput.setUniqueKey(getInput.getUniqueKey());
+      GetOutput sourceGetOutput = new GetAction().execute(sourceGetInput);
+      QRecord   outputRecord    = sourceGetOutput.getRecord();
+
+      return (outputRecord);
+   }
+   */
+
+}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/tables/helpers/QueryActionCacheHelper.java

@@ -0,0 +1,622 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2023.  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.tables.helpers;
+
+
+import java.io.Serializable;
+import java.time.Instant;
+import java.time.temporal.ChronoUnit;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+import com.kingsrook.qqq.backend.core.actions.tables.DeleteAction;
+import com.kingsrook.qqq.backend.core.actions.tables.GetAction;
+import com.kingsrook.qqq.backend.core.actions.tables.InsertAction;
+import com.kingsrook.qqq.backend.core.actions.tables.QueryAction;
+import com.kingsrook.qqq.backend.core.actions.tables.UpdateAction;
+import com.kingsrook.qqq.backend.core.context.QContext;
+import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
+import com.kingsrook.qqq.backend.core.model.actions.tables.delete.DeleteInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.get.GetInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.get.GetOutput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.insert.InsertInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.insert.InsertOutput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QCriteriaOperator;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QFilterCriteria;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QQueryFilter;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryOutput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.update.UpdateInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.update.UpdateOutput;
+import com.kingsrook.qqq.backend.core.model.data.QRecord;
+import com.kingsrook.qqq.backend.core.model.metadata.QBackendMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.tables.Capability;
+import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.tables.UniqueKey;
+import com.kingsrook.qqq.backend.core.model.metadata.tables.cache.CacheUseCase;
+import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
+import com.kingsrook.qqq.backend.core.utils.ListingHash;
+import org.apache.commons.lang.NotImplementedException;
+import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
+
+
+/*******************************************************************************
+ ** After running a query, if it's for a table that's a CacheOf another table,
+ ** see if there are any cache use-cases to apply to the query result.
+ **
+ ** Such as:
+ ** - if it's a query for one or more values in a UniqueKey:
+ **   - if any particular UniqueKeys weren't found, look in the source table
+ ** - if any cached records are expired, refresh them from the source
+ **   - possibly updating the cached record; possibly deleting it.
+ *******************************************************************************/
+public class QueryActionCacheHelper
+{
+   private static final QLogger LOG = QLogger.getLogger(QueryActionCacheHelper.class);
+
+   private boolean                              isQueryInputCacheable = false;
+   private Map<CacheUseCase.Type, CacheUseCase> cacheUseCaseMap       = new HashMap<>();
+   private CacheUseCase                         activeCacheUseCase    = null;
+
+   private UniqueKey                         cacheUniqueKey  = null;
+   private ListingHash<String, Serializable> uniqueKeyValues = new ListingHash<>();
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public void handleCaching(QueryInput queryInput, QueryOutput queryOutput) throws QException
+   {
+      analyzeInput(queryInput);
+      if(!isQueryInputCacheable)
+      {
+         return;
+      }
+
+      //////////////////////////////////////////////////////////////////////////
+      // figure out which keys in the query were found, and which were missed //
+      //////////////////////////////////////////////////////////////////////////
+      List<QRecord>           recordsFoundInCache           = new ArrayList<>(queryOutput.getRecords());
+      Set<List<Serializable>> uniqueKeyValuesInFoundRecords = getUniqueKeyValuesFromFoundRecords(queryOutput.getRecords());
+      Set<List<Serializable>> missedUniqueKeyValues         = getUniqueKeyValuesFromQuery();
+      missedUniqueKeyValues.removeAll(uniqueKeyValuesInFoundRecords);
+
+      ///////////////////////////////////////////////////////////////////////////////////
+      // if any requested records weren't found, see if we should look in cache-source //
+      ///////////////////////////////////////////////////////////////////////////////////
+      if(CollectionUtils.nullSafeHasContents(missedUniqueKeyValues))
+      {
+         List<QRecord> recordsFromSource = tryToGetFromCacheSource(queryInput, missedUniqueKeyValues);
+         if(CollectionUtils.nullSafeHasContents(recordsFromSource))
+         {
+            //////////////////////////////////////////////////////////////////////////////////////////////////
+            // good, we found records from the source, make sure we should cache them, and if so, do it now //
+            // note, we always return the record from the source, even if we don't cache it.                //
+            //////////////////////////////////////////////////////////////////////////////////////////////////
+            QTableMetaData table = queryInput.getTable();
+
+            List<QRecord> recordsToReturn = recordsFromSource.stream()
+               .map(r -> CacheUtils.mapSourceRecordToCacheRecord(table, r, activeCacheUseCase))
+               .toList();
+            queryOutput.addRecords(recordsToReturn);
+
+            List<QRecord> recordsToCache = recordsToReturn.stream()
+               .filter(r -> CacheUtils.shouldCacheRecord(table, r))
+               .toList();
+
+            if(CollectionUtils.nullSafeHasContents(recordsToCache))
+            {
+               try
+               {
+                  InsertInput insertInput = new InsertInput();
+                  insertInput.setTableName(queryInput.getTableName());
+                  insertInput.setRecords(recordsToCache);
+                  insertInput.setSkipUniqueKeyCheck(true);
+                  InsertOutput insertOutput = new InsertAction().execute(insertInput);
+
+                  //////////////////////////////////////////////////////////
+                  // set the (generated) ids in the records being returne //
+                  //////////////////////////////////////////////////////////
+                  Map<List<Serializable>, QRecord> insertedRecordsByUniqueKey = new HashMap<>();
+                  for(QRecord record : insertOutput.getRecords())
+                  {
+                     insertedRecordsByUniqueKey.put(getUniqueKeyValues(record), record);
+                  }
+                  for(QRecord record : recordsToReturn)
+                  {
+                     QRecord insertedRecord = insertedRecordsByUniqueKey.get(getUniqueKeyValues(record));
+                     if(insertedRecord != null)
+                     {
+                        record.setValue(table.getPrimaryKeyField(), insertedRecord.getValue(table.getPrimaryKeyField()));
+                     }
+                  }
+               }
+               catch(Exception e)
+               {
+                  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                  // don't let an exception break this query - it (probably) just indicates some data that didn't get cached - so - that's generally "ok" //
+                  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                  LOG.warn("Error inserting cached records", e, logPair("cacheTable", queryInput.getTableName()));
+               }
+            }
+         }
+      }
+
+      //////////////////////////////////////////////////////////////////////////
+      // for records that were found, if they're too old, maybe re-fetch them //
+      //////////////////////////////////////////////////////////////////////////
+      if(CollectionUtils.nullSafeHasContents(recordsFoundInCache))
+      {
+         refreshCacheIfExpired(recordsFoundInCache, queryInput, queryOutput);
+      }
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private void refreshCacheIfExpired(List<QRecord> recordsFoundInCache, QueryInput queryInput, QueryOutput queryOutput) throws QException
+   {
+      QTableMetaData table             = queryInput.getTable();
+      Integer        expirationSeconds = table.getCacheOf().getExpirationSeconds();
+
+      if(expirationSeconds != null)
+      {
+         List<QRecord> expiredRecords = new ArrayList<>();
+         for(QRecord cachedRecord : recordsFoundInCache)
+         {
+            Instant cachedDate = cachedRecord.getValueInstant(table.getCacheOf().getCachedDateFieldName());
+            if(cachedDate == null || cachedDate.isBefore(Instant.now().minus(expirationSeconds, ChronoUnit.SECONDS)))
+            {
+               expiredRecords.add(cachedRecord);
+            }
+         }
+
+         if(CollectionUtils.nullSafeHasContents(expiredRecords))
+         {
+            Map<List<Serializable>, Serializable> uniqueKeyToPrimaryKeyMap = getUniqueKeyToPrimaryKeyMap(table.getPrimaryKeyField(), expiredRecords);
+            Set<List<Serializable>>               uniqueKeyValuesToRefresh = uniqueKeyToPrimaryKeyMap.keySet();
+
+            ////////////////////////////////////////////
+            // fetch records from original source now //
+            ////////////////////////////////////////////
+            List<QRecord> recordsFromSource = tryToGetFromCacheSource(queryInput, uniqueKeyValuesToRefresh);
+
+            Set<List<Serializable>> uniqueKeyValuesInFoundRecords = getUniqueKeyValuesFromFoundRecords(recordsFromSource);
+            Set<List<Serializable>> missedUniqueKeyValues         = getUniqueKeyValuesFromQuery();
+            missedUniqueKeyValues.retainAll(getUniqueKeyValuesFromFoundRecords(expiredRecords));
+            missedUniqueKeyValues.removeAll(uniqueKeyValuesInFoundRecords);
+
+            //////////////////////////////////////////////////////////////////////////////////////////////////////
+            // build records to cache - setting their original (from cache) ids back in them, so they'll update //
+            //////////////////////////////////////////////////////////////////////////////////////////////////////
+            List<QRecord> refreshedRecordsToReturn = recordsFromSource.stream()
+               .map(r ->
+               {
+                  QRecord recordToCache = CacheUtils.mapSourceRecordToCacheRecord(table, r, activeCacheUseCase);
+                  recordToCache.setValue(table.getPrimaryKeyField(), uniqueKeyToPrimaryKeyMap.get(getUniqueKeyValues(recordToCache)));
+                  return (recordToCache);
+               })
+               .toList();
+
+            ///////////////////////////////////////////////////////////////////////////////////////////////////////
+            // if the records were found in the source, put it into the output object so returned back to caller //
+            ///////////////////////////////////////////////////////////////////////////////////////////////////////
+            Map<List<Serializable>, QRecord> refreshedRecordsByUniqueKeyValues = refreshedRecordsToReturn.stream().collect(Collectors.toMap(this::getUniqueKeyValues, r -> r, (a, b) -> a));
+
+            ListIterator<QRecord> queryOutputListIterator = queryOutput.getRecords().listIterator();
+            while(queryOutputListIterator.hasNext())
+            {
+               QRecord            originalRecord        = queryOutputListIterator.next();
+               List<Serializable> recordUniqueKeyValues = getUniqueKeyValues(originalRecord);
+               QRecord            refreshedRecord       = refreshedRecordsByUniqueKeyValues.get(recordUniqueKeyValues);
+
+               if(refreshedRecord != null)
+               {
+                  queryOutputListIterator.set(refreshedRecord);
+               }
+               else if(missedUniqueKeyValues.contains(recordUniqueKeyValues))
+               {
+                  queryOutputListIterator.remove();
+               }
+            }
+
+            ////////////////////////////////////////////////////////////////////////////
+            // for refreshed records which should be cached, update them in the cache //
+            ////////////////////////////////////////////////////////////////////////////
+            List<QRecord> recordsToUpdate = refreshedRecordsToReturn.stream().filter(r -> CacheUtils.shouldCacheRecord(table, r)).toList();
+            if(CollectionUtils.nullSafeHasContents(recordsToUpdate))
+            {
+               try
+               {
+                  UpdateInput updateInput = new UpdateInput();
+                  updateInput.setTableName(queryInput.getTableName());
+                  updateInput.setRecords(recordsToUpdate);
+                  UpdateOutput updateOutput = new UpdateAction().execute(updateInput);
+               }
+               catch(Exception e)
+               {
+                  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                  // don't let an exception break this query - it (probably) just indicates some data that didn't get cached - so - that's generally "ok" //
+                  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                  LOG.warn("Error updating cached records", e, logPair("cacheTable", queryInput.getTableName()));
+               }
+            }
+
+            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+            // if the records were missed in the source - OR if they shouldn't be cached now, then mark them for deleting //
+            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+            Set<Serializable> cachedRecordIdsToDelete = missedUniqueKeyValues.stream()
+               .map(uniqueKeyToPrimaryKeyMap::get)
+               .collect(Collectors.toSet());
+
+            cachedRecordIdsToDelete.addAll(refreshedRecordsToReturn.stream()
+               .filter(r -> !CacheUtils.shouldCacheRecord(table, r))
+               .map(r -> r.getValue(table.getPrimaryKeyField()))
+               .collect(Collectors.toSet()));
+
+            if(CollectionUtils.nullSafeHasContents(cachedRecordIdsToDelete))
+            {
+               /////////////////////////////////////////////////////////////////////////////////
+               // if the records are no longer in the source, then remove them from the cache //
+               /////////////////////////////////////////////////////////////////////////////////
+               try
+               {
+                  DeleteInput deleteInput = new DeleteInput();
+                  deleteInput.setTableName(queryInput.getTableName());
+                  deleteInput.setPrimaryKeys(new ArrayList<>(cachedRecordIdsToDelete));
+                  new DeleteAction().execute(deleteInput);
+
+               }
+               catch(Exception e)
+               {
+                  ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                  // don't let an exception break this query - it (probably) just indicates some data that didn't get uncached - so - that's generally "ok" //
+                  ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                  LOG.warn("Error deleting cached records", e, logPair("cacheTable", queryInput.getTableName()));
+               }
+            }
+         }
+      }
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private Set<List<Serializable>> getUniqueKeyValuesFromQuery()
+   {
+      Set<List<Serializable>> rs = new HashSet<>();
+
+      int noOfUniqueKeys = uniqueKeyValues.get(cacheUniqueKey.getFieldNames().get(0)).size();
+      for(int i = 0; i < noOfUniqueKeys; i++)
+      {
+         List<Serializable> values = new ArrayList<>();
+
+         for(String fieldName : cacheUniqueKey.getFieldNames())
+         {
+            values.add(uniqueKeyValues.get(fieldName).get(i));
+         }
+
+         ////////////////////////////////////////////////////////////////////////////////
+         // critical - leave this here so hashCode from the list is correctly computed //
+         ////////////////////////////////////////////////////////////////////////////////
+         rs.add(values);
+      }
+
+      return (rs);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private Set<List<Serializable>> getUniqueKeyValuesFromFoundRecords(List<QRecord> records)
+   {
+      return (getUniqueKeyToPrimaryKeyMap("ignore", records).keySet());
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private Map<List<Serializable>, Serializable> getUniqueKeyToPrimaryKeyMap(String primaryKeyField, List<QRecord> records)
+   {
+      Map<List<Serializable>, Serializable> rs = new HashMap<>();
+
+      for(QRecord record : records)
+      {
+         List<Serializable> uniqueKeyValues = getUniqueKeyValues(record);
+         rs.put(uniqueKeyValues, record.getValue(primaryKeyField));
+      }
+
+      return (rs);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private List<Serializable> getUniqueKeyValues(QRecord record)
+   {
+      List<Serializable> uniqueKeyValues = new ArrayList<>();
+      for(String fieldName : cacheUniqueKey.getFieldNames())
+      {
+         uniqueKeyValues.add(record.getValue(fieldName));
+      }
+      return uniqueKeyValues;
+   }
+
+
+
+   /*******************************************************************************
+    ** figure out if this was a request that we can cache records for -
+    ** e.g., if it's a request for unique-key EQUALS or IN
+    ** build up fields for the unique keys, the values, etc.
+    *******************************************************************************/
+   private void analyzeInput(QueryInput queryInput)
+   {
+      QTableMetaData table = queryInput.getTable();
+
+      for(CacheUseCase cacheUseCase : CollectionUtils.nonNullList(table.getCacheOf().getUseCases()))
+      {
+         cacheUseCaseMap.put(cacheUseCase.getType(), cacheUseCase);
+      }
+
+      if(cacheUseCaseMap.containsKey(CacheUseCase.Type.UNIQUE_KEY_TO_UNIQUE_KEY))
+      {
+         if(queryInput.getFilter() == null)
+         {
+            LOG.trace("Unable to cache: there is no filter");
+            return;
+         }
+
+         QQueryFilter filter      = queryInput.getFilter();
+         Set<String>  queryFields = new HashSet<>();
+         if(CollectionUtils.nullSafeHasContents(filter.getSubFilters()))
+         {
+            if(CollectionUtils.nullSafeHasContents(filter.getCriteria()))
+            {
+               LOG.trace("Unable to cache: we have sub-filters and criteria");
+               return;
+            }
+
+            if(!QQueryFilter.BooleanOperator.OR.equals(filter.getBooleanOperator()))
+            {
+               LOG.trace("Unable to cache: we have sub-filters but not an OR query");
+               return;
+            }
+
+            /////////////////////////
+            // look at sub-filters //
+            /////////////////////////
+            for(QQueryFilter subFilter : filter.getSubFilters())
+            {
+               Set<String> thisSubFilterFields = getQueryFieldsIfCacheableFilter(subFilter, false);
+               if(thisSubFilterFields == null)
+               {
+                  return;
+               }
+
+               if(queryFields.isEmpty())
+               {
+                  queryFields.addAll(thisSubFilterFields);
+               }
+               else
+               {
+                  if(!queryFields.equals(thisSubFilterFields))
+                  {
+                     LOG.trace("Unable to cache: sub-filters have different sets of fields");
+                     return;
+                  }
+               }
+            }
+
+            if(doQueryFieldsMatchAUniqueKey(table, queryFields))
+            {
+               return;
+            }
+
+            LOG.trace("Unable to cache: we have sub-filters that do match a unique key");
+            return;
+         }
+         else
+         {
+            //////////////////////////////////////////
+            // look at the criteria in the query:   //
+            // - build a set of field names         //
+            // - fail upon unsupported operators    //
+            // - collect the values in the criteria //
+            //////////////////////////////////////////
+            queryFields = getQueryFieldsIfCacheableFilter(filter, true);
+            if(queryFields == null)
+            {
+               return;
+            }
+         }
+
+         if(doQueryFieldsMatchAUniqueKey(table, queryFields))
+         {
+            return;
+         }
+
+         LOG.trace("Unable to cache: we have query fields that don't match a unique key: " + queryFields);
+         return;
+      }
+
+      LOG.trace("Unable to cache: No supported use case: " + cacheUseCaseMap.keySet());
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private boolean doQueryFieldsMatchAUniqueKey(QTableMetaData table, Set<String> queryFields)
+   {
+      for(UniqueKey uniqueKey : CollectionUtils.nonNullList(table.getUniqueKeys()))
+      {
+         if(queryFields.equals(new HashSet<>(uniqueKey.getFieldNames())))
+         {
+            this.cacheUniqueKey = uniqueKey;
+            isQueryInputCacheable = true;
+            activeCacheUseCase = cacheUseCaseMap.get(CacheUseCase.Type.UNIQUE_KEY_TO_UNIQUE_KEY);
+            return true;
+         }
+      }
+      return false;
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private Set<String> getQueryFieldsIfCacheableFilter(QQueryFilter filter, boolean allowOperatorIn)
+   {
+      Set<String> rs = new HashSet<>();
+      for(QFilterCriteria criterion : filter.getCriteria())
+      {
+         boolean isEquals = criterion.getOperator().equals(QCriteriaOperator.EQUALS);
+         boolean isIn     = criterion.getOperator().equals(QCriteriaOperator.IN);
+
+         if(isEquals || (isIn && allowOperatorIn))
+         {
+            rs.add(criterion.getFieldName());
+            this.uniqueKeyValues.addAll(criterion.getFieldName(), criterion.getValues());
+         }
+         else
+         {
+            LOG.trace("Unable to cache: we have an unsupported criteria operator: " + criterion.getOperator());
+            isQueryInputCacheable = false;
+            return (null);
+         }
+      }
+      return (rs);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private List<QRecord> tryToGetFromCacheSource(QueryInput queryInput, Set<List<Serializable>> uniqueKeyValues) throws QException
+   {
+      List<QRecord>  recordsFromSource = null;
+      QTableMetaData table             = queryInput.getTable();
+
+      if(CacheUseCase.Type.UNIQUE_KEY_TO_UNIQUE_KEY.equals(activeCacheUseCase.getType()))
+      {
+         recordsFromSource = getFromCachedSourceForUniqueKeyToUniqueKey(queryInput, uniqueKeyValues, table.getCacheOf().getSourceTable());
+      }
+      else
+      {
+         // todo!!
+         throw (new NotImplementedException("Not-yet-implemented cache use case type: " + activeCacheUseCase.getType()));
+      }
+
+      return (recordsFromSource);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private List<QRecord> getFromCachedSourceForUniqueKeyToUniqueKey(QueryInput cacheQueryInput, Set<List<Serializable>> uniqueKeyValues, String sourceTableName) throws QException
+   {
+      QTableMetaData   sourceTable   = QContext.getQInstance().getTable(sourceTableName);
+      QBackendMetaData sourceBackend = QContext.getQInstance().getBackendForTable(sourceTableName);
+
+      if(sourceTable.isCapabilityEnabled(sourceBackend, Capability.TABLE_QUERY))
+      {
+         ///////////////////////////////////////////////////////
+         // do a Query on the source table, by the unique key //
+         ///////////////////////////////////////////////////////
+         QueryInput sourceQueryInput = new QueryInput();
+         sourceQueryInput.setTableName(sourceTableName);
+
+         QQueryFilter filter = new QQueryFilter().withBooleanOperator(QQueryFilter.BooleanOperator.OR);
+         sourceQueryInput.setFilter(filter);
+         sourceQueryInput.setCommonParamsFrom(cacheQueryInput);
+
+         for(List<Serializable> uniqueKeyValue : uniqueKeyValues)
+         {
+            QQueryFilter subFilter = new QQueryFilter();
+            filter.addSubFilter(subFilter);
+
+            for(int i = 0; i < cacheUniqueKey.getFieldNames().size(); i++)
+            {
+               subFilter.addCriteria(new QFilterCriteria(cacheUniqueKey.getFieldNames().get(i), QCriteriaOperator.EQUALS, uniqueKeyValue.get(i)));
+            }
+         }
+
+         QueryOutput sourceQueryOutput = new QueryAction().execute(sourceQueryInput);
+         return (sourceQueryOutput.getRecords());
+      }
+      else if(sourceTable.isCapabilityEnabled(sourceBackend, Capability.TABLE_GET))
+      {
+         ///////////////////////////////////////////////////////////////////////
+         // if the table only supports GET, then do a GET for each unique key //
+         ///////////////////////////////////////////////////////////////////////
+         List<QRecord> outputRecords = new ArrayList<>();
+         for(List<Serializable> uniqueKeyValue : uniqueKeyValues)
+         {
+            Map<String, Serializable> uniqueKey = new HashMap<>();
+            for(int i = 0; i < cacheUniqueKey.getFieldNames().size(); i++)
+            {
+               uniqueKey.put(cacheUniqueKey.getFieldNames().get(i), uniqueKeyValue.get(i));
+            }
+
+            GetInput getInput = new GetInput();
+            getInput.setTableName(sourceTableName);
+            getInput.setUniqueKey(uniqueKey);
+            getInput.setCommonParamsFrom(cacheQueryInput);
+            GetOutput getOutput = new GetAction().execute(getInput);
+
+            if(getOutput.getRecord() != null)
+            {
+               outputRecords.add(getOutput.getRecord());
+            }
+         }
+
+         return (outputRecords);
+      }
+      else
+      {
+         throw (new QException("Cache source table " + sourceTableName + " does not support Query or Get capability."));
+      }
+   }
+
+}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/tables/helpers/QueryStatManager.java

@@ -0,0 +1,640 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2023.  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.tables.helpers;
+
+
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Supplier;
+import com.kingsrook.qqq.backend.core.actions.tables.GetAction;
+import com.kingsrook.qqq.backend.core.actions.tables.InsertAction;
+import com.kingsrook.qqq.backend.core.context.QContext;
+import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.instances.QMetaDataVariableInterpreter;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
+import com.kingsrook.qqq.backend.core.model.actions.tables.get.GetInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.get.GetOutput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.insert.InsertInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.insert.InsertOutput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QFilterCriteria;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QFilterOrderBy;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QQueryFilter;
+import com.kingsrook.qqq.backend.core.model.data.QRecord;
+import com.kingsrook.qqq.backend.core.model.metadata.QBackendMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.QInstance;
+import com.kingsrook.qqq.backend.core.model.metadata.tables.Capability;
+import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
+import com.kingsrook.qqq.backend.core.model.querystats.QueryStat;
+import com.kingsrook.qqq.backend.core.model.querystats.QueryStatCriteriaField;
+import com.kingsrook.qqq.backend.core.model.querystats.QueryStatJoinTable;
+import com.kingsrook.qqq.backend.core.model.querystats.QueryStatOrderByField;
+import com.kingsrook.qqq.backend.core.model.session.QSession;
+import com.kingsrook.qqq.backend.core.model.tables.QQQTable;
+import com.kingsrook.qqq.backend.core.model.tables.QQQTablesMetaDataProvider;
+import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
+import com.kingsrook.qqq.backend.core.utils.StringUtils;
+import com.kingsrook.qqq.backend.core.utils.collections.MapBuilder;
+import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
+
+
+/*******************************************************************************
+ ** Singleton, which starts a thread, to store query stats into a table.
+ **
+ ** Supports these systemProperties or ENV_VARS:
+ ** qqq.queryStatManager.enabled / QQQ_QUERY_STAT_MANAGER_ENABLED
+ ** qqq.queryStatManager.minMillisToStore / QQQ_QUERY_STAT_MANAGER_MIN_MILLIS_TO_STORE
+ ** qqq.queryStatManager.jobPeriodSeconds / QQQ_QUERY_STAT_MANAGER_JOB_PERIOD_SECONDS
+ ** qqq.queryStatManager.jobInitialDelay / QQQ_QUERY_STAT_MANAGER_JOB_INITIAL_DELAY
+ *******************************************************************************/
+public class QueryStatManager
+{
+   private static final QLogger LOG = QLogger.getLogger(QueryStatManager.class);
+
+   private static QueryStatManager queryStatManager = null;
+
+   // todo - support multiple qInstances?
+   private QInstance          qInstance;
+   private Supplier<QSession> sessionSupplier;
+
+   private boolean         active     = false;
+   private List<QueryStat> queryStats = new ArrayList<>();
+
+   private ScheduledExecutorService executorService;
+
+   private int jobPeriodSeconds = 60;
+   private int jobInitialDelay  = 60;
+   private int minMillisToStore = 0;
+
+
+
+   /*******************************************************************************
+    ** Singleton constructor
+    *******************************************************************************/
+   private QueryStatManager()
+   {
+
+   }
+
+
+
+   /*******************************************************************************
+    ** Singleton accessor
+    *******************************************************************************/
+   public static QueryStatManager getInstance()
+   {
+      if(queryStatManager == null)
+      {
+         queryStatManager = new QueryStatManager();
+
+         QMetaDataVariableInterpreter interpreter = new QMetaDataVariableInterpreter();
+
+         Integer propertyMinMillisToStore = interpreter.getIntegerFromPropertyOrEnvironment("qqq.queryStatManager.minMillisToStore", "QQQ_QUERY_STAT_MANAGER_MIN_MILLIS_TO_STORE", null);
+         if(propertyMinMillisToStore != null)
+         {
+            queryStatManager.setMinMillisToStore(propertyMinMillisToStore);
+         }
+
+         Integer propertyJobPeriodSeconds = interpreter.getIntegerFromPropertyOrEnvironment("qqq.queryStatManager.jobPeriodSeconds", "QQQ_QUERY_STAT_MANAGER_JOB_PERIOD_SECONDS", null);
+         if(propertyJobPeriodSeconds != null)
+         {
+            queryStatManager.setJobPeriodSeconds(propertyJobPeriodSeconds);
+         }
+
+         Integer propertyJobInitialDelay = interpreter.getIntegerFromPropertyOrEnvironment("qqq.queryStatManager.jobInitialDelay", "QQQ_QUERY_STAT_MANAGER_JOB_INITIAL_DELAY", null);
+         if(propertyJobInitialDelay != null)
+         {
+            queryStatManager.setJobInitialDelay(propertyJobInitialDelay);
+         }
+
+      }
+      return (queryStatManager);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public static QueryStat newQueryStat(QBackendMetaData backend, QTableMetaData table, QQueryFilter filter)
+   {
+      QueryStat queryStat = null;
+
+      if(table.isCapabilityEnabled(backend, Capability.QUERY_STATS))
+      {
+         queryStat = new QueryStat();
+         queryStat.setTableName(table.getName());
+         queryStat.setQueryFilter(Objects.requireNonNullElse(filter, new QQueryFilter()));
+         queryStat.setStartTimestamp(Instant.now());
+      }
+
+      return (queryStat);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public void start(QInstance qInstance, Supplier<QSession> sessionSupplier)
+   {
+      if(!isEnabled())
+      {
+         LOG.info("Not starting QueryStatManager per settings.");
+         return;
+      }
+
+      LOG.info("Starting QueryStatManager");
+
+      this.qInstance = qInstance;
+      this.sessionSupplier = sessionSupplier;
+
+      active = true;
+      queryStats = new ArrayList<>();
+
+      executorService = Executors.newSingleThreadScheduledExecutor();
+      executorService.scheduleAtFixedRate(new QueryStatManagerInsertJob(), jobInitialDelay, jobPeriodSeconds, TimeUnit.SECONDS);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private static boolean isEnabled()
+   {
+      return new QMetaDataVariableInterpreter().getBooleanFromPropertyOrEnvironment("qqq.queryStatManager.enabled", "QQQ_QUERY_STAT_MANAGER_ENABLED", true);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public void stop()
+   {
+      active = false;
+      queryStats.clear();
+
+      if(executorService != null)
+      {
+         executorService.shutdown();
+         executorService = null;
+      }
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public void add(QueryStat queryStat)
+   {
+      if(queryStat == null)
+      {
+         return;
+      }
+
+      if(active)
+      {
+         ////////////////////////////////////////////////////////////////////////////////////////
+         // set fields that we need to capture now (rather than when the thread to store runs) //
+         ////////////////////////////////////////////////////////////////////////////////////////
+         if(queryStat.getFirstResultTimestamp() == null)
+         {
+            queryStat.setFirstResultTimestamp(Instant.now());
+         }
+
+         if(queryStat.getStartTimestamp() != null && queryStat.getFirstResultTimestamp() != null && queryStat.getFirstResultMillis() == null)
+         {
+            long millis = queryStat.getFirstResultTimestamp().toEpochMilli() - queryStat.getStartTimestamp().toEpochMilli();
+            queryStat.setFirstResultMillis((int) millis);
+         }
+
+         if(queryStat.getFirstResultMillis() != null && queryStat.getFirstResultMillis() < minMillisToStore)
+         {
+            //////////////////////////////////////////////////////////////
+            // discard this record if it's under the min millis setting //
+            //////////////////////////////////////////////////////////////
+            return;
+         }
+
+         if(queryStat.getSessionId() == null && QContext.getQSession() != null)
+         {
+            queryStat.setSessionId(QContext.getQSession().getUuid());
+         }
+
+         if(queryStat.getAction() == null)
+         {
+            if(!QContext.getActionStack().isEmpty())
+            {
+               queryStat.setAction(QContext.getActionStack().peek().getActionIdentity());
+            }
+            else
+            {
+               boolean   expected = false;
+               Exception e        = new Exception("Unexpected empty action stack");
+               for(StackTraceElement stackTraceElement : e.getStackTrace())
+               {
+                  String className = stackTraceElement.getClassName();
+                  if(className.contains(QueryStatManagerInsertJob.class.getName()))
+                  {
+                     expected = true;
+                     break;
+                  }
+               }
+
+               if(!expected)
+               {
+                  LOG.debug(e);
+               }
+            }
+         }
+
+         synchronized(this)
+         {
+            queryStats.add(queryStat);
+         }
+      }
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private List<QueryStat> getListAndReset()
+   {
+      if(queryStats.isEmpty())
+      {
+         return Collections.emptyList();
+      }
+
+      synchronized(this)
+      {
+         List<QueryStat> returnList = queryStats;
+         queryStats = new ArrayList<>();
+         return (returnList);
+      }
+   }
+
+
+
+   /*******************************************************************************
+    ** force stats to be stored right now (rather than letting the scheduled job do it)
+    *******************************************************************************/
+   public void storeStatsNow()
+   {
+      new QueryStatManagerInsertJob().run();
+   }
+
+
+
+   /*******************************************************************************
+    ** Runnable that gets scheduled to periodically reset and store the list of collected stats
+    *******************************************************************************/
+   private static class QueryStatManagerInsertJob implements Runnable
+   {
+      private static final QLogger LOG = QLogger.getLogger(QueryStatManagerInsertJob.class);
+
+
+
+      /*******************************************************************************
+       **
+       *******************************************************************************/
+      @Override
+      public void run()
+      {
+         try
+         {
+            QContext.init(getInstance().qInstance, getInstance().sessionSupplier.get());
+
+            /////////////////////////////////////////////////////////////////////////////////////
+            // every time we re-run, check if we've been turned off - if so, stop the service. //
+            /////////////////////////////////////////////////////////////////////////////////////
+            if(!isEnabled())
+            {
+               LOG.info("Stopping QueryStatManager.");
+               getInstance().stop();
+               return;
+            }
+
+            List<QueryStat> list = getInstance().getListAndReset();
+
+            LOG.info(logPair("queryStatListSize", list.size()));
+
+            if(list.isEmpty())
+            {
+               return;
+            }
+
+            ////////////////////////////////////
+            // prime the entities for storing //
+            ////////////////////////////////////
+            List<QRecord> queryStatQRecordsToInsert = new ArrayList<>();
+            for(QueryStat queryStat : list)
+            {
+               try
+               {
+                  //////////////////////
+                  // set the table id //
+                  //////////////////////
+                  Integer qqqTableId = getQQQTableId(queryStat.getTableName());
+                  queryStat.setQqqTableId(qqqTableId);
+
+                  //////////////////////////////
+                  // build join-table records //
+                  //////////////////////////////
+                  if(CollectionUtils.nullSafeHasContents(queryStat.getJoinTableNames()))
+                  {
+                     List<QueryStatJoinTable> queryStatJoinTableList = new ArrayList<>();
+                     for(String joinTableName : queryStat.getJoinTableNames())
+                     {
+                        queryStatJoinTableList.add(new QueryStatJoinTable().withQqqTableId(getQQQTableId(joinTableName)));
+                     }
+                     queryStat.setQueryStatJoinTableList(queryStatJoinTableList);
+                  }
+
+                  ////////////////////////////
+                  // build criteria records //
+                  ////////////////////////////
+                  if(queryStat.getQueryFilter() != null && queryStat.getQueryFilter().hasAnyCriteria())
+                  {
+                     List<QueryStatCriteriaField> queryStatCriteriaFieldList = new ArrayList<>();
+                     processCriteriaFromFilter(qqqTableId, queryStatCriteriaFieldList, queryStat.getQueryFilter());
+                     queryStat.setQueryStatCriteriaFieldList(queryStatCriteriaFieldList);
+                  }
+
+                  if(CollectionUtils.nullSafeHasContents(queryStat.getQueryFilter().getOrderBys()))
+                  {
+                     List<QueryStatOrderByField> queryStatOrderByFieldList = new ArrayList<>();
+                     processOrderByFromFilter(qqqTableId, queryStatOrderByFieldList, queryStat.getQueryFilter());
+                     queryStat.setQueryStatOrderByFieldList(queryStatOrderByFieldList);
+                  }
+
+                  queryStatQRecordsToInsert.add(queryStat.toQRecord());
+               }
+               catch(Exception e)
+               {
+                  //////////////////////
+                  // skip this record //
+                  //////////////////////
+                  LOG.warn("Error priming a query stat for storing", e);
+               }
+            }
+
+            try
+            {
+               InsertInput insertInput = new InsertInput();
+               insertInput.setTableName(QueryStat.TABLE_NAME);
+               insertInput.setRecords(queryStatQRecordsToInsert);
+               new InsertAction().execute(insertInput);
+            }
+            catch(Exception e)
+            {
+               LOG.error("Error inserting query stats", e);
+            }
+         }
+         catch(Exception e)
+         {
+            LOG.warn("Error storing query stats", e);
+         }
+         finally
+         {
+            QContext.clear();
+         }
+      }
+
+
+
+      /*******************************************************************************
+       **
+       *******************************************************************************/
+      private static void processCriteriaFromFilter(Integer qqqTableId, List<QueryStatCriteriaField> queryStatCriteriaFieldList, QQueryFilter queryFilter) throws QException
+      {
+         for(QFilterCriteria criteria : CollectionUtils.nonNullList(queryFilter.getCriteria()))
+         {
+            String                 fieldName              = criteria.getFieldName();
+            QueryStatCriteriaField queryStatCriteriaField = new QueryStatCriteriaField();
+            queryStatCriteriaField.setOperator(String.valueOf(criteria.getOperator()));
+
+            if(criteria.getValues() != null)
+            {
+               queryStatCriteriaField.setValues(StringUtils.join(",", criteria.getValues()));
+            }
+
+            if(fieldName.contains("."))
+            {
+               String[] parts = fieldName.split("\\.");
+               if(parts.length > 1)
+               {
+                  queryStatCriteriaField.setQqqTableId(getQQQTableId(parts[0]));
+                  queryStatCriteriaField.setName(parts[1]);
+               }
+            }
+            else
+            {
+               queryStatCriteriaField.setQqqTableId(qqqTableId);
+               queryStatCriteriaField.setName(fieldName);
+            }
+
+            queryStatCriteriaFieldList.add(queryStatCriteriaField);
+         }
+
+         for(QQueryFilter subFilter : CollectionUtils.nonNullList(queryFilter.getSubFilters()))
+         {
+            processCriteriaFromFilter(qqqTableId, queryStatCriteriaFieldList, subFilter);
+         }
+      }
+
+
+
+      /*******************************************************************************
+       **
+       *******************************************************************************/
+      private static void processOrderByFromFilter(Integer qqqTableId, List<QueryStatOrderByField> queryStatOrderByFieldList, QQueryFilter queryFilter) throws QException
+      {
+         for(QFilterOrderBy orderBy : CollectionUtils.nonNullList(queryFilter.getOrderBys()))
+         {
+            String                fieldName             = orderBy.getFieldName();
+            QueryStatOrderByField queryStatOrderByField = new QueryStatOrderByField();
+
+            if(fieldName != null)
+            {
+               if(fieldName.contains("."))
+               {
+                  String[] parts = fieldName.split("\\.");
+                  if(parts.length > 1)
+                  {
+                     queryStatOrderByField.setQqqTableId(getQQQTableId(parts[0]));
+                     queryStatOrderByField.setName(parts[1]);
+                  }
+               }
+               else
+               {
+                  queryStatOrderByField.setQqqTableId(qqqTableId);
+                  queryStatOrderByField.setName(fieldName);
+               }
+
+               queryStatOrderByFieldList.add(queryStatOrderByField);
+            }
+         }
+      }
+
+
+
+      /*******************************************************************************
+       **
+       *******************************************************************************/
+      private static Integer getQQQTableId(String tableName) throws QException
+      {
+         /////////////////////////////
+         // look in the cache table //
+         /////////////////////////////
+         GetInput getInput = new GetInput();
+         getInput.setTableName(QQQTablesMetaDataProvider.QQQ_TABLE_CACHE_TABLE_NAME);
+         getInput.setUniqueKey(MapBuilder.of("name", tableName));
+         GetOutput getOutput = new GetAction().execute(getInput);
+
+         ////////////////////////
+         // upon cache miss... //
+         ////////////////////////
+         if(getOutput.getRecord() == null)
+         {
+            ///////////////////////////////////////////////////////
+            // insert the record (into the table, not the cache) //
+            ///////////////////////////////////////////////////////
+            QTableMetaData tableMetaData = getInstance().qInstance.getTable(tableName);
+            InsertInput    insertInput   = new InsertInput();
+            insertInput.setTableName(QQQTable.TABLE_NAME);
+            insertInput.setRecords(List.of(new QRecord().withValue("name", tableName).withValue("label", tableMetaData.getLabel())));
+            InsertOutput insertOutput = new InsertAction().execute(insertInput);
+
+            ///////////////////////////////////
+            // repeat the get from the cache //
+            ///////////////////////////////////
+            getOutput = new GetAction().execute(getInput);
+         }
+
+         return getOutput.getRecord().getValueInteger("id");
+      }
+   }
+
+
+
+   /*******************************************************************************
+    ** Getter for jobPeriodSeconds
+    *******************************************************************************/
+   public int getJobPeriodSeconds()
+   {
+      return (this.jobPeriodSeconds);
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for jobPeriodSeconds
+    *******************************************************************************/
+   public void setJobPeriodSeconds(int jobPeriodSeconds)
+   {
+      this.jobPeriodSeconds = jobPeriodSeconds;
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for jobPeriodSeconds
+    *******************************************************************************/
+   public QueryStatManager withJobPeriodSeconds(int jobPeriodSeconds)
+   {
+      this.jobPeriodSeconds = jobPeriodSeconds;
+      return (this);
+   }
+
+
+
+   /*******************************************************************************
+    ** Getter for jobInitialDelay
+    *******************************************************************************/
+   public int getJobInitialDelay()
+   {
+      return (this.jobInitialDelay);
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for jobInitialDelay
+    *******************************************************************************/
+   public void setJobInitialDelay(int jobInitialDelay)
+   {
+      this.jobInitialDelay = jobInitialDelay;
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for jobInitialDelay
+    *******************************************************************************/
+   public QueryStatManager withJobInitialDelay(int jobInitialDelay)
+   {
+      this.jobInitialDelay = jobInitialDelay;
+      return (this);
+   }
+
+
+
+   /*******************************************************************************
+    ** Getter for minMillisToStore
+    *******************************************************************************/
+   public int getMinMillisToStore()
+   {
+      return (this.minMillisToStore);
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for minMillisToStore
+    *******************************************************************************/
+   public void setMinMillisToStore(int minMillisToStore)
+   {
+      this.minMillisToStore = minMillisToStore;
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for minMillisToStore
+    *******************************************************************************/
+   public QueryStatManager withMinMillisToStore(int minMillisToStore)
+   {
+      this.minMillisToStore = minMillisToStore;
+      return (this);
+   }
+
+}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/tables/helpers/UniqueKeyHelper.java

@@ -24,15 +24,14 @@ package com.kingsrook.qqq.backend.core.actions.tables.helpers;
 
 import java.io.Serializable;
 import java.util.ArrayList;
-import java.util.HashSet;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.Optional;
-import java.util.Set;
 import java.util.stream.Collectors;
 import com.kingsrook.qqq.backend.core.actions.QBackendTransaction;
 import com.kingsrook.qqq.backend.core.actions.tables.QueryAction;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
-import com.kingsrook.qqq.backend.core.model.actions.AbstractActionInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QCriteriaOperator;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QFilterCriteria;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QQueryFilter;
@@ -55,14 +54,13 @@ public class UniqueKeyHelper
    /*******************************************************************************
     **
     *******************************************************************************/
-   public static Set<List<Serializable>> getExistingKeys(AbstractActionInput actionInput, QBackendTransaction transaction, QTableMetaData table, List<QRecord> recordList, UniqueKey uniqueKey) throws QException
+   public static Map<List<Serializable>, Serializable> getExistingKeys(QBackendTransaction transaction, QTableMetaData table, List<QRecord> recordList, UniqueKey uniqueKey) throws QException
    {
-      List<String>            ukFieldNames    = uniqueKey.getFieldNames();
-      Set<List<Serializable>> existingRecords = new HashSet<>();
+      List<String>                          ukFieldNames    = uniqueKey.getFieldNames();
+      Map<List<Serializable>, Serializable> existingRecords = new HashMap<>();
       if(ukFieldNames != null)
       {
-         QueryInput queryInput = new QueryInput(actionInput.getInstance());
-         queryInput.setSession(actionInput.getSession());
+         QueryInput queryInput = new QueryInput();
          queryInput.setTableName(table.getName());
          queryInput.setTransaction(transaction);
 
@@ -115,8 +113,10 @@ public class UniqueKeyHelper
          for(QRecord record : queryOutput.getRecords())
          {
             Optional<List<Serializable>> keyValues = getKeyValues(table, uniqueKey, record);
-            keyValues.ifPresent(existingRecords::add);
-
+            if(keyValues.isPresent())
+            {
+               existingRecords.put(keyValues.get(), record.getValue(table.getPrimaryKeyField()));
+            }
          }
       }
 

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/tables/helpers/ValidateRecordSecurityLockHelper.java

@@ -0,0 +1,327 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2023.  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.tables.helpers;
+
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import com.kingsrook.qqq.backend.core.actions.tables.QueryAction;
+import com.kingsrook.qqq.backend.core.context.QContext;
+import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QCriteriaOperator;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QFilterCriteria;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QQueryFilter;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryJoin;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryOutput;
+import com.kingsrook.qqq.backend.core.model.data.QRecord;
+import com.kingsrook.qqq.backend.core.model.metadata.fields.QFieldMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.fields.QFieldType;
+import com.kingsrook.qqq.backend.core.model.metadata.joins.JoinOn;
+import com.kingsrook.qqq.backend.core.model.metadata.joins.QJoinMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.security.QSecurityKeyType;
+import com.kingsrook.qqq.backend.core.model.metadata.security.RecordSecurityLock;
+import com.kingsrook.qqq.backend.core.model.metadata.security.RecordSecurityLockFilters;
+import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
+import com.kingsrook.qqq.backend.core.model.statusmessages.PermissionDeniedMessage;
+import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
+import com.kingsrook.qqq.backend.core.utils.ListingHash;
+import com.kingsrook.qqq.backend.core.utils.StringUtils;
+import com.kingsrook.qqq.backend.core.utils.ValueUtils;
+
+
+/*******************************************************************************
+ **
+ *******************************************************************************/
+public class ValidateRecordSecurityLockHelper
+{
+   private static final QLogger LOG = QLogger.getLogger(ValidateRecordSecurityLockHelper.class);
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public enum Action
+   {
+      INSERT,
+      UPDATE,
+      DELETE,
+      SELECT
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public static void validateSecurityFields(QTableMetaData table, List<QRecord> records, Action action) throws QException
+   {
+      List<RecordSecurityLock> locksToCheck = getRecordSecurityLocks(table, action);
+      if(CollectionUtils.nullSafeIsEmpty(locksToCheck))
+      {
+         return;
+      }
+
+      ////////////////////////////////
+      // actually check lock values //
+      ////////////////////////////////
+      for(RecordSecurityLock recordSecurityLock : locksToCheck)
+      {
+         if(CollectionUtils.nullSafeIsEmpty(recordSecurityLock.getJoinNameChain()))
+         {
+            //////////////////////////////////////////////////////////////////////////////////
+            // handle the value being in the table we're inserting/updating (e.g., no join) //
+            //////////////////////////////////////////////////////////////////////////////////
+            QFieldMetaData field = table.getField(recordSecurityLock.getFieldName());
+
+            for(QRecord record : records)
+            {
+               if(action.equals(Action.UPDATE) && !record.getValues().containsKey(field.getName()) && RecordSecurityLock.LockScope.READ_AND_WRITE.equals(recordSecurityLock.getLockScope()))
+               {
+                  /////////////////////////////////////////////////////////////////////////////////////////////////////////
+                  // if this is a read-write lock, then if we have the record, it means we were able to read the record. //
+                  // So if we're not updating the security field, then no error can come from it!                        //
+                  /////////////////////////////////////////////////////////////////////////////////////////////////////////
+                  continue;
+               }
+
+               Serializable recordSecurityValue = record.getValue(field.getName());
+               validateRecordSecurityValue(table, record, recordSecurityLock, recordSecurityValue, field.getType(), action);
+            }
+         }
+         else
+         {
+            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+            // else look for the joined record - if it isn't found, assume a fail - else validate security value if found //
+            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+            QJoinMetaData  leftMostJoin       = QContext.getQInstance().getJoin(recordSecurityLock.getJoinNameChain().get(0));
+            QJoinMetaData  rightMostJoin      = QContext.getQInstance().getJoin(recordSecurityLock.getJoinNameChain().get(recordSecurityLock.getJoinNameChain().size() - 1));
+            QTableMetaData rightMostJoinTable = QContext.getQInstance().getTable(rightMostJoin.getRightTable());
+            QTableMetaData leftMostJoinTable  = QContext.getQInstance().getTable(leftMostJoin.getLeftTable());
+
+            for(List<QRecord> inputRecordPage : CollectionUtils.getPages(records, 500))
+            {
+               ////////////////////////////////////////////////////////////////////////////////////////////////
+               // set up a query for joined records                                                          //
+               // query will be like (fkey1=? and fkey2=?) OR (fkey1=? and fkey2=?) OR (fkey1=? and fkey2=?) //
+               ////////////////////////////////////////////////////////////////////////////////////////////////
+               QueryInput queryInput = new QueryInput();
+               queryInput.setTableName(leftMostJoin.getLeftTable());
+               QQueryFilter filter = new QQueryFilter().withBooleanOperator(QQueryFilter.BooleanOperator.OR);
+               queryInput.setFilter(filter);
+
+               for(String joinName : recordSecurityLock.getJoinNameChain())
+               {
+                  ///////////////////////////////////////
+                  // we don't need the right-most join //
+                  ///////////////////////////////////////
+                  if(!joinName.equals(rightMostJoin.getName()))
+                  {
+                     queryInput.withQueryJoin(new QueryJoin().withJoinMetaData(QContext.getQInstance().getJoin(joinName)).withSelect(true));
+                  }
+               }
+
+               ///////////////////////////////////////////////////////////////////////////////////////////////////
+               // foreach input record (in this page), put it in a listing hash, with key = list of join-values //
+               // e.g., (17,47)=(QRecord1), (18,48)=(QRecord2,QRecord3)                                         //
+               // also build up the query's sub-filters here (only adding them if they're unique).              //
+               // e.g., 2 order-lines referencing the same orderId don't need to be added to the query twice    //
+               ///////////////////////////////////////////////////////////////////////////////////////////////////
+               ListingHash<List<Serializable>, QRecord> inputRecordMapByJoinFields = new ListingHash<>();
+               for(QRecord inputRecord : inputRecordPage)
+               {
+                  List<Serializable> inputRecordJoinValues = new ArrayList<>();
+                  QQueryFilter       subFilter             = new QQueryFilter();
+
+                  for(JoinOn joinOn : rightMostJoin.getJoinOns())
+                  {
+                     QFieldType   type             = rightMostJoinTable.getField(joinOn.getRightField()).getType();
+                     Serializable inputRecordValue = ValueUtils.getValueAsFieldType(type, inputRecord.getValue(joinOn.getRightField()));
+                     inputRecordJoinValues.add(inputRecordValue);
+
+                     subFilter.addCriteria(inputRecordValue == null
+                        ? new QFilterCriteria(rightMostJoin.getLeftTable() + "." + joinOn.getLeftField(), QCriteriaOperator.IS_BLANK)
+                        : new QFilterCriteria(rightMostJoin.getLeftTable() + "." + joinOn.getLeftField(), QCriteriaOperator.EQUALS, inputRecordValue));
+                  }
+
+                  if(!inputRecordMapByJoinFields.containsKey(inputRecordJoinValues))
+                  {
+                     ////////////////////////////////////////////////////////////////////////////////
+                     // only add this sub-filter if it's for a list of keys we haven't seen before //
+                     ////////////////////////////////////////////////////////////////////////////////
+                     filter.addSubFilter(subFilter);
+                  }
+
+                  inputRecordMapByJoinFields.add(inputRecordJoinValues, inputRecord);
+               }
+
+               //////////////////////////////////////////////////////////////////////////////////////////////////////////////
+               // execute the query for joined records - then put them in a map with keys corresponding to the join values //
+               // e.g., (17,47)=(JoinRecord), (18,48)=(JoinRecord)                                                         //
+               //////////////////////////////////////////////////////////////////////////////////////////////////////////////
+               QueryOutput                      queryOutput               = new QueryAction().execute(queryInput);
+               Map<List<Serializable>, QRecord> joinRecordMapByJoinFields = new HashMap<>();
+               for(QRecord joinRecord : queryOutput.getRecords())
+               {
+                  List<Serializable> joinRecordValues = new ArrayList<>();
+                  for(JoinOn joinOn : rightMostJoin.getJoinOns())
+                  {
+                     Serializable joinValue = joinRecord.getValue(rightMostJoin.getLeftTable() + "." + joinOn.getLeftField());
+                     if(joinValue == null && joinRecord.getValues().keySet().stream().anyMatch(n -> !n.contains(".")))
+                     {
+                        joinValue = joinRecord.getValue(joinOn.getLeftField());
+                     }
+                     joinRecordValues.add(joinValue);
+                  }
+
+                  joinRecordMapByJoinFields.put(joinRecordValues, joinRecord);
+               }
+
+               //////////////////////////////////////////////////////////////////////////////////////////////////
+               // now for each input record, look for its joinRecord - if it isn't found, then this insert     //
+               // isn't allowed.  if it is found, then validate its value matches this session's security keys //
+               //////////////////////////////////////////////////////////////////////////////////////////////////
+               for(Map.Entry<List<Serializable>, List<QRecord>> entry : inputRecordMapByJoinFields.entrySet())
+               {
+                  List<Serializable> inputRecordJoinValues = entry.getKey();
+                  List<QRecord>      inputRecords          = entry.getValue();
+                  if(joinRecordMapByJoinFields.containsKey(inputRecordJoinValues))
+                  {
+                     QRecord joinRecord = joinRecordMapByJoinFields.get(inputRecordJoinValues);
+
+                     String         fieldName           = recordSecurityLock.getFieldName().replaceFirst(".*\\.", "");
+                     QFieldMetaData field               = leftMostJoinTable.getField(fieldName);
+                     Serializable   recordSecurityValue = joinRecord.getValue(fieldName);
+                     if(recordSecurityValue == null && joinRecord.getValues().keySet().stream().anyMatch(n -> n.contains(".")))
+                     {
+                        recordSecurityValue = joinRecord.getValue(recordSecurityLock.getFieldName());
+                     }
+
+                     for(QRecord inputRecord : inputRecords)
+                     {
+                        validateRecordSecurityValue(table, inputRecord, recordSecurityLock, recordSecurityValue, field.getType(), action);
+                     }
+                  }
+                  else
+                  {
+                     for(QRecord inputRecord : inputRecords)
+                     {
+                        if(RecordSecurityLock.NullValueBehavior.DENY.equals(recordSecurityLock.getNullValueBehavior()))
+                        {
+                           inputRecord.addError(new PermissionDeniedMessage("You do not have permission to " + action.name().toLowerCase() + " this record - the referenced " + leftMostJoinTable.getLabel() + " was not found."));
+                        }
+                     }
+                  }
+               }
+            }
+         }
+      }
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private static List<RecordSecurityLock> getRecordSecurityLocks(QTableMetaData table, Action action)
+   {
+      List<RecordSecurityLock> recordSecurityLocks = CollectionUtils.nonNullList(table.getRecordSecurityLocks());
+      List<RecordSecurityLock> locksToCheck        = new ArrayList<>();
+
+      recordSecurityLocks = switch(action)
+      {
+         case INSERT, UPDATE, DELETE -> RecordSecurityLockFilters.filterForWriteLocks(recordSecurityLocks);
+         case SELECT -> RecordSecurityLockFilters.filterForReadLocks(recordSecurityLocks);
+         default -> throw (new IllegalArgumentException("Unsupported action: " + action));
+      };
+
+      ////////////////////////////////////////
+      // if there are no locks, just return //
+      ////////////////////////////////////////
+      if(CollectionUtils.nullSafeIsEmpty(recordSecurityLocks))
+      {
+         return (null);
+      }
+
+      ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // decide if any locks need checked - where one may not need checked if it has an all-access key, and the user has all-access //
+      ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      for(RecordSecurityLock recordSecurityLock : recordSecurityLocks)
+      {
+         QSecurityKeyType securityKeyType = QContext.getQInstance().getSecurityKeyType(recordSecurityLock.getSecurityKeyType());
+         if(StringUtils.hasContent(securityKeyType.getAllAccessKeyName()) && QContext.getQSession().hasSecurityKeyValue(securityKeyType.getAllAccessKeyName(), true, QFieldType.BOOLEAN))
+         {
+            LOG.trace("Session has " + securityKeyType.getAllAccessKeyName() + " - not checking this lock.");
+         }
+         else
+         {
+            locksToCheck.add(recordSecurityLock);
+         }
+      }
+
+      return (locksToCheck);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public static void validateRecordSecurityValue(QTableMetaData table, QRecord record, RecordSecurityLock recordSecurityLock, Serializable recordSecurityValue, QFieldType fieldType, Action action)
+   {
+      if(recordSecurityValue == null)
+      {
+         /////////////////////////////////////////////////////////////////
+         // handle null values - error if the NullValueBehavior is DENY //
+         /////////////////////////////////////////////////////////////////
+         if(RecordSecurityLock.NullValueBehavior.DENY.equals(recordSecurityLock.getNullValueBehavior()))
+         {
+            String lockLabel = CollectionUtils.nullSafeHasContents(recordSecurityLock.getJoinNameChain()) ? recordSecurityLock.getSecurityKeyType() : table.getField(recordSecurityLock.getFieldName()).getLabel();
+            record.addError(new PermissionDeniedMessage("You do not have permission to " + action.name().toLowerCase() + " a record without a value in the field: " + lockLabel));
+         }
+      }
+      else
+      {
+         if(!QContext.getQSession().hasSecurityKeyValue(recordSecurityLock.getSecurityKeyType(), recordSecurityValue, fieldType))
+         {
+            if(CollectionUtils.nullSafeHasContents(recordSecurityLock.getJoinNameChain()))
+            {
+               ///////////////////////////////////////////////////////////////////////////////////////////////
+               // avoid telling the user a value from a foreign record that they didn't pass in themselves. //
+               ///////////////////////////////////////////////////////////////////////////////////////////////
+               record.addError(new PermissionDeniedMessage("You do not have permission to " + action.name().toLowerCase() + " this record."));
+            }
+            else
+            {
+               QFieldMetaData field = table.getField(recordSecurityLock.getFieldName());
+               record.addError(new PermissionDeniedMessage("You do not have permission to " + action.name().toLowerCase() + " a record with a value of " + recordSecurityValue + " in the field: " + field.getLabel()));
+            }
+         }
+      }
+   }
+
+}

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

@@ -26,8 +26,8 @@ import java.nio.file.Path;
 import java.util.Map;
 import com.kingsrook.qqq.backend.core.actions.AbstractQActionFunction;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
-import com.kingsrook.qqq.backend.core.model.templates.ConvertHtmlToPdfInput;
-import com.kingsrook.qqq.backend.core.model.templates.ConvertHtmlToPdfOutput;
+import com.kingsrook.qqq.backend.core.model.actions.templates.ConvertHtmlToPdfInput;
+import com.kingsrook.qqq.backend.core.model.actions.templates.ConvertHtmlToPdfOutput;
 import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
 import org.jsoup.Jsoup;
 import org.jsoup.nodes.Document;

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

@@ -26,20 +26,30 @@ import java.io.StringWriter;
 import java.util.Map;
 import com.kingsrook.qqq.backend.core.actions.AbstractQActionFunction;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
 import com.kingsrook.qqq.backend.core.model.actions.AbstractActionInput;
-import com.kingsrook.qqq.backend.core.model.templates.RenderTemplateInput;
-import com.kingsrook.qqq.backend.core.model.templates.RenderTemplateOutput;
+import com.kingsrook.qqq.backend.core.model.actions.templates.RenderTemplateInput;
+import com.kingsrook.qqq.backend.core.model.actions.templates.RenderTemplateOutput;
 import com.kingsrook.qqq.backend.core.model.templates.TemplateType;
+import com.kingsrook.qqq.backend.core.utils.StringUtils;
 import org.apache.velocity.VelocityContext;
 import org.apache.velocity.app.Velocity;
+import org.apache.velocity.app.event.EventCartridge;
+import org.apache.velocity.app.event.MethodExceptionEventHandler;
 import org.apache.velocity.context.Context;
+import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
 
 
 /*******************************************************************************
  ** Basic action to render a template!
+ **
+ ** hard-coded built to only assume Velocity right now.  could expand (and refactor) in future.
  *******************************************************************************/
 public class RenderTemplateAction extends AbstractQActionFunction<RenderTemplateInput, RenderTemplateOutput>
 {
+   private static final QLogger LOG = QLogger.getLogger(RenderTemplateAction.class);
+
+
 
    /*******************************************************************************
     **
@@ -52,9 +62,20 @@ public class RenderTemplateAction extends AbstractQActionFunction<RenderTemplate
       if(TemplateType.VELOCITY.equals(input.getTemplateType()))
       {
          Velocity.init();
-         Context      context      = new VelocityContext(input.getContext());
+         Context context = new VelocityContext();
+
+         if(input.getContext() != null)
+         {
+            for(Map.Entry<String, ?> entry : input.getContext().entrySet())
+            {
+               context.put(entry.getKey(), entry.getValue());
+            }
+         }
+
+         setupEventHandlers(context);
+
          StringWriter stringWriter = new StringWriter();
-         Velocity.evaluate(context, stringWriter, "logTag", input.getCode());
+         Velocity.evaluate(context, stringWriter, StringUtils.hasContent(input.getTemplateIdentifier()) ? input.getTemplateIdentifier() : "anonymous", input.getCode());
          output.setResult(stringWriter.getBuffer().toString());
       }
       else
@@ -67,12 +88,28 @@ public class RenderTemplateAction extends AbstractQActionFunction<RenderTemplate
 
 
 
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private static void setupEventHandlers(Context context)
+   {
+      EventCartridge eventCartridge = new EventCartridge();
+      eventCartridge.addEventHandler((MethodExceptionEventHandler) (ctx, aClass, method, exception, info) ->
+      {
+         LOG.info("Exception in velocity template", exception, logPair("at", info.toString()));
+         return (null);
+      });
+      eventCartridge.attachToContext(context);
+   }
+
+
+
    /*******************************************************************************
     ** Most convenient static wrapper to render a Velocity template.
     *******************************************************************************/
    public static String renderVelocity(AbstractActionInput parentActionInput, Map<String, Object> context, String code) throws QException
    {
-      return (render(parentActionInput, TemplateType.VELOCITY, context, code));
+      return (render(TemplateType.VELOCITY, context, code));
    }
 
 
@@ -80,10 +117,9 @@ public class RenderTemplateAction extends AbstractQActionFunction<RenderTemplate
    /*******************************************************************************
     ** Convenient static wrapper to render a template of an arbitrary type (language).
     *******************************************************************************/
-   public static String render(AbstractActionInput parentActionInput, TemplateType templateType, Map<String, Object> context, String code) throws QException
+   public static String render(TemplateType templateType, Map<String, Object> context, String code) throws QException
    {
-      RenderTemplateInput renderTemplateInput = new RenderTemplateInput(parentActionInput.getInstance());
-      renderTemplateInput.setSession(parentActionInput.getSession());
+      RenderTemplateInput renderTemplateInput = new RenderTemplateInput();
       renderTemplateInput.setCode(code);
       renderTemplateInput.setContext(context);
       renderTemplateInput.setTemplateType(templateType);

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

@@ -23,21 +23,81 @@ 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;
+import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
+import com.kingsrook.qqq.backend.core.utils.StringUtils;
+import com.kingsrook.qqq.backend.core.utils.ValueUtils;
 
 
 /*******************************************************************************
  ** Interface to be implemented by user-defined code that serves as the backing
  ** for a CUSTOM type possibleValueSource
+ **
+ ** Type parameter `T` is the id-type of the possible value.
  *******************************************************************************/
-public interface QCustomPossibleValueProvider
+public interface QCustomPossibleValueProvider<T extends Serializable>
 {
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   QPossibleValue<T> getPossibleValue(Serializable idValue);
 
    /*******************************************************************************
     **
     *******************************************************************************/
-   QPossibleValue<?> getPossibleValue(Serializable idValue);
+   List<QPossibleValue<T>> search(SearchPossibleValueSourceInput input) throws QException;
 
-   // todo - get/search list of possible values
 
+   /*******************************************************************************
+    ** The input list of ids might come through as a type that isn't the same as
+    ** the type of the ids in the enum (e.g., strings from a frontend, integers
+    ** in an enum).  So, this method looks maps a list of input ids to the requested type.
+    *******************************************************************************/
+   default List<T> convertInputIdsToIdType(Class<T> type, List<Serializable> inputIdList)
+   {
+      List<T> rs = new ArrayList<>();
+      if(CollectionUtils.nullSafeIsEmpty(inputIdList))
+      {
+         return (rs);
+      }
+
+      for(Serializable serializable : inputIdList)
+      {
+         rs.add(ValueUtils.getValueAsType(type, serializable));
+      }
+
+      return (rs);
+   }
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   default boolean doesPossibleValueMatchSearchInput(List<T> idsInType, QPossibleValue<T> possibleValue, SearchPossibleValueSourceInput input)
+   {
+      boolean match = false;
+      if(input.getIdList() != null)
+      {
+         if(idsInType.contains(possibleValue.getId()))
+         {
+            match = true;
+         }
+      }
+      else
+      {
+         if(StringUtils.hasContent(input.getSearchTerm()))
+         {
+            match = possibleValue.getLabel().toLowerCase().startsWith(input.getSearchTerm().toLowerCase());
+         }
+         else
+         {
+            match = true;
+         }
+      }
+      return match;
+   }
 }

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

@@ -34,7 +34,9 @@ import java.util.Objects;
 import java.util.Set;
 import com.kingsrook.qqq.backend.core.actions.customizers.QCodeLoader;
 import com.kingsrook.qqq.backend.core.actions.tables.QueryAction;
+import com.kingsrook.qqq.backend.core.context.QContext;
 import com.kingsrook.qqq.backend.core.exceptions.QValueException;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QCriteriaOperator;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QFilterCriteria;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QQueryFilter;
@@ -55,8 +57,7 @@ import com.kingsrook.qqq.backend.core.utils.ListingHash;
 import com.kingsrook.qqq.backend.core.utils.Pair;
 import com.kingsrook.qqq.backend.core.utils.StringUtils;
 import com.kingsrook.qqq.backend.core.utils.ValueUtils;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
+import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
 
 
 /*******************************************************************************
@@ -65,16 +66,25 @@ import org.apache.logging.log4j.Logger;
  *******************************************************************************/
 public class QPossibleValueTranslator
 {
-   private static final Logger LOG = LogManager.getLogger(QPossibleValueTranslator.class);
-
-   private final QInstance qInstance;
-   private final QSession  session;
+   private static final QLogger LOG = QLogger.getLogger(QPossibleValueTranslator.class);
 
    ///////////////////////////////////////////////////////
    // top-level keys are pvsNames (not table names)     //
    // 2nd-level keys are pkey values from the PVS table //
    ///////////////////////////////////////////////////////
-   private Map<String, Map<Serializable, String>> possibleValueCache;
+   private Map<String, Map<Serializable, String>> possibleValueCache = new HashMap<>();
+
+   // todo not commit - remove instance & session - use Context
+
+
+
+   /*******************************************************************************
+    ** Constructor
+    **
+    *******************************************************************************/
+   public QPossibleValueTranslator()
+   {
+   }
 
 
 
@@ -83,10 +93,6 @@ public class QPossibleValueTranslator
     *******************************************************************************/
    public QPossibleValueTranslator(QInstance qInstance, QSession session)
    {
-      this.qInstance = qInstance;
-      this.session = session;
-
-      this.possibleValueCache = new HashMap<>();
    }
 
 
@@ -117,7 +123,7 @@ public class QPossibleValueTranslator
          return;
       }
 
-      LOG.debug("Translating possible values in [" + records.size() + "] records from the [" + table.getName() + "] table.");
+      LOG.trace("Translating possible values in [" + records.size() + "] records from the [" + table.getName() + "] table.");
       primePvsCache(table, records, queryJoins, limitedToFieldNames);
 
       for(QRecord record : records)
@@ -139,7 +145,7 @@ public class QPossibleValueTranslator
             {
                try
                {
-                  QTableMetaData joinTable = qInstance.getTable(queryJoin.getJoinTable());
+                  QTableMetaData joinTable = QContext.getQInstance().getTable(queryJoin.getJoinTable());
                   for(QFieldMetaData field : joinTable.getFields().values())
                   {
                      String joinFieldName = Objects.requireNonNullElse(queryJoin.getAlias(), joinTable.getName()) + "." + field.getName();
@@ -150,7 +156,7 @@ public class QPossibleValueTranslator
                            ///////////////////////////////////////////////
                            // avoid circling-back upon the source table //
                            ///////////////////////////////////////////////
-                           QPossibleValueSource possibleValueSource = qInstance.getPossibleValueSource(field.getPossibleValueSourceName());
+                           QPossibleValueSource possibleValueSource = QContext.getQInstance().getPossibleValueSource(field.getPossibleValueSourceName());
                            if(QPossibleValueSourceType.TABLE.equals(possibleValueSource.getType()) && table.getName().equals(possibleValueSource.getTableName()))
                            {
                               continue;
@@ -210,7 +216,7 @@ public class QPossibleValueTranslator
     *******************************************************************************/
    public String translatePossibleValue(QFieldMetaData field, Serializable value)
    {
-      QPossibleValueSource possibleValueSource = qInstance.getPossibleValueSource(field.getPossibleValueSourceName());
+      QPossibleValueSource possibleValueSource = QContext.getQInstance().getPossibleValueSource(field.getPossibleValueSourceName());
       if(possibleValueSource == null)
       {
          LOG.error("Missing possible value source named [" + field.getPossibleValueSourceName() + "] when formatting value for field [" + field.getName() + "]");
@@ -372,11 +378,11 @@ public class QPossibleValueTranslator
          for(String valueField : valueFields)
          {
             Object value = switch(valueField)
-               {
-                  case "id" -> id;
-                  case "label" -> label;
-                  default -> throw new IllegalArgumentException("Unexpected value field: " + valueField);
-               };
+            {
+               case "id" -> id;
+               case "label" -> label;
+               default -> throw new IllegalArgumentException("Unexpected value field: " + valueField);
+            };
             values.add(Objects.requireNonNullElse(value, ""));
          }
       }
@@ -412,7 +418,16 @@ public class QPossibleValueTranslator
          if(queryJoin.getSelect())
          {
             String aliasOrTableName = Objects.requireNonNullElse(queryJoin.getAlias(), queryJoin.getJoinTable());
-            primePvsCacheTableListingHashLoader(qInstance.getTable(queryJoin.getJoinTable()), fieldsByPvsTable, pvsesByTable, aliasOrTableName + ".", queryJoin.getJoinTable(), limitedToFieldNames);
+            primePvsCacheTableListingHashLoader(QContext.getQInstance().getTable(queryJoin.getJoinTable()), fieldsByPvsTable, pvsesByTable, aliasOrTableName + ".", queryJoin.getJoinTable(), limitedToFieldNames);
+         }
+      }
+
+      for(Map.Entry<String, Map<Serializable, String>> entry : possibleValueCache.entrySet())
+      {
+         int size = entry.getValue().size();
+         if(size > 50_000)
+         {
+            LOG.info("Found a big PVS cache - clearing it.", logPair("name", entry.getKey()), logPair("size", size));
          }
       }
 
@@ -463,12 +478,12 @@ public class QPossibleValueTranslator
    {
       for(QFieldMetaData field : table.getFields().values())
       {
-         QPossibleValueSource possibleValueSource = qInstance.getPossibleValueSource(field.getPossibleValueSourceName());
+         QPossibleValueSource possibleValueSource = QContext.getQInstance().getPossibleValueSource(field.getPossibleValueSourceName());
          if(possibleValueSource != null && possibleValueSource.getType().equals(QPossibleValueSourceType.TABLE))
          {
             if(limitedToFieldNames != null && !limitedToFieldNames.contains(fieldNamePrefix + field.getName()))
             {
-               LOG.debug("Skipping cache priming for translation of possible value field [" + fieldNamePrefix + field.getName() + "] - it's not in the limitedToFieldNames set.");
+               LOG.trace("Skipping cache priming for translation of possible value field [" + fieldNamePrefix + field.getName() + "] - it's not in the limitedToFieldNames set.");
                continue;
             }
 
@@ -499,12 +514,11 @@ public class QPossibleValueTranslator
 
       try
       {
-         String primaryKeyField = qInstance.getTable(tableName).getPrimaryKeyField();
+         String primaryKeyField = QContext.getQInstance().getTable(tableName).getPrimaryKeyField();
 
          for(List<Serializable> page : CollectionUtils.getPages(values, 1000))
          {
-            QueryInput queryInput = new QueryInput(qInstance);
-            queryInput.setSession(session);
+            QueryInput queryInput = new QueryInput();
             queryInput.setTableName(tableName);
             queryInput.setFilter(new QQueryFilter().withCriteria(new QFilterCriteria(primaryKeyField, QCriteriaOperator.IN, page)));
 
@@ -521,7 +535,7 @@ public class QPossibleValueTranslator
             {
                if(possibleValueSource.getType().equals(QPossibleValueSourceType.TABLE))
                {
-                  QTableMetaData table = qInstance.getTable(possibleValueSource.getTableName());
+                  QTableMetaData table = QContext.getQInstance().getTable(possibleValueSource.getTableName());
                   for(String recordLabelField : CollectionUtils.nonNullList(table.getRecordLabelFields()))
                   {
                      QFieldMetaData field = table.getField(recordLabelField);
@@ -542,7 +556,7 @@ public class QPossibleValueTranslator
                queryInput.setFieldsToTranslatePossibleValues(possibleValueFieldsToTranslate);
             }
 
-            LOG.debug("Priming PVS cache for [" + page.size() + "] ids from [" + tableName + "] table.");
+            LOG.trace("Priming PVS cache for [" + page.size() + "] ids from [" + tableName + "] table.");
             QueryOutput queryOutput = new QueryAction().execute(queryInput);
 
             ///////////////////////////////////////////////////////////////////////////////////

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

@@ -25,18 +25,28 @@ package com.kingsrook.qqq.backend.core.actions.values;
 import java.io.Serializable;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.ZonedDateTime;
 import java.time.format.DateTimeFormatter;
 import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
+import com.kingsrook.qqq.backend.core.context.QContext;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
 import com.kingsrook.qqq.backend.core.model.data.QRecord;
+import com.kingsrook.qqq.backend.core.model.metadata.fields.AdornmentType;
+import com.kingsrook.qqq.backend.core.model.metadata.fields.FieldAdornment;
 import com.kingsrook.qqq.backend.core.model.metadata.fields.QFieldMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.fields.QFieldType;
+import com.kingsrook.qqq.backend.core.model.metadata.tables.ExposedJoin;
 import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
+import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
 import com.kingsrook.qqq.backend.core.utils.StringUtils;
 import com.kingsrook.qqq.backend.core.utils.ValueUtils;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
+import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
 
 
 /*******************************************************************************
@@ -45,10 +55,12 @@ import org.apache.logging.log4j.Logger;
  *******************************************************************************/
 public class QValueFormatter
 {
-   private static final Logger LOG = LogManager.getLogger(QValueFormatter.class);
+   private static final QLogger LOG = QLogger.getLogger(QValueFormatter.class);
 
-   private static DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd h:mm a");
-   private static DateTimeFormatter dateFormatter     = DateTimeFormatter.ofPattern("yyyy-MM-dd");
+   private static DateTimeFormatter dateTimeFormatter         = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss a");
+   private static DateTimeFormatter dateTimeWithZoneFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss a z");
+   private static DateTimeFormatter dateFormatter             = DateTimeFormatter.ofPattern("yyyy-MM-dd");
+   private static DateTimeFormatter localTimeFormatter        = DateTimeFormatter.ofPattern("h:mm:ss a");
 
 
 
@@ -57,23 +69,6 @@ public class QValueFormatter
     *******************************************************************************/
    public static String formatValue(QFieldMetaData field, Serializable value)
    {
-      if(QFieldType.BOOLEAN.equals(field.getType()))
-      {
-         Boolean b = ValueUtils.getValueAsBoolean(value);
-         if(b == null)
-         {
-            return (null);
-         }
-         else if(b)
-         {
-            return ("Yes");
-         }
-         else
-         {
-            return ("No");
-         }
-      }
-
       return (formatValue(field.getDisplayFormat(), field.getName(), value));
    }
 
@@ -103,6 +98,22 @@ public class QValueFormatter
          return (null);
       }
 
+      ////////////////////////////////////////////////////////////////////////////////////////////////
+      // try to apply some type-specific defaults, if we were requested to just format as a string. //
+      ////////////////////////////////////////////////////////////////////////////////////////////////
+      if("%s".equals(displayFormat))
+      {
+         if(value instanceof Boolean b)
+         {
+            return formatBoolean(b);
+         }
+
+         if(value instanceof LocalTime lt)
+         {
+            return formatLocalTime(lt);
+         }
+      }
+
       ////////////////////////////////////////////////////////
       // if the field has a display format, try to apply it //
       ////////////////////////////////////////////////////////
@@ -125,7 +136,7 @@ public class QValueFormatter
                {
                   return formatValue(displayFormat, ValueUtils.getValueAsBigDecimal(value));
                }
-               else if(e.getMessage().equals("d != java.math.BigDecimal"))
+               else if(e.getMessage().equals("d != java.math.BigDecimal") || e.getMessage().equals("d != java.lang.String"))
                {
                   return formatValue(displayFormat, ValueUtils.getValueAsInteger(value));
                }
@@ -169,6 +180,26 @@ public class QValueFormatter
 
 
 
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public static String formatDateTimeWithZone(ZonedDateTime dateTime)
+   {
+      return (dateTimeWithZoneFormatter.format(dateTime));
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public static String formatLocalTime(LocalTime localTime)
+   {
+      return (localTimeFormatter.format(localTime));
+   }
+
+
+
    /*******************************************************************************
     ** Make a string from a table's recordLabelFormat and fields, for a given record.
     *******************************************************************************/
@@ -261,7 +292,8 @@ public class QValueFormatter
 
 
    /*******************************************************************************
-    ** For a list of records, set their recordLabels and display values
+    ** For a list of records, set their recordLabels and display values - including
+    ** record label (e.g., from the table meta data).
     *******************************************************************************/
    public static void setDisplayValuesInRecords(QTableMetaData table, List<QRecord> records)
    {
@@ -270,15 +302,87 @@ public class QValueFormatter
          return;
       }
 
+      Map<String, QFieldMetaData> fieldMap = new HashMap<>();
+
       for(QRecord record : records)
       {
-         setDisplayValuesInRecord(table.getFields().values(), record);
+         for(String fieldName : record.getValues().keySet())
+         {
+            if(!fieldMap.containsKey(fieldName))
+            {
+               try
+               {
+                  if(fieldName.contains("."))
+                  {
+                     String[] nameParts = fieldName.split("\\.", 2);
+                     for(ExposedJoin exposedJoin : CollectionUtils.nonNullList(table.getExposedJoins()))
+                     {
+                        if(exposedJoin.getJoinTable().equals(nameParts[0]))
+                        {
+                           QTableMetaData joinTable = QContext.getQInstance().getTable(nameParts[0]);
+                           fieldMap.put(fieldName, joinTable.getField(nameParts[1]));
+                        }
+                     }
+                  }
+                  else
+                  {
+                     fieldMap.put(fieldName, table.getField(fieldName));
+                  }
+               }
+               catch(Exception e)
+               {
+                  ///////////////////////////////////////////////////////////
+                  // put an empty field in - so no formatting will be done //
+                  ///////////////////////////////////////////////////////////
+                  LOG.info("Error getting field for setting display value", e, logPair("fieldName", fieldName), logPair("tableName", table.getName()));
+                  fieldMap.put(fieldName, new QFieldMetaData());
+               }
+            }
+         }
+
+         setDisplayValuesInRecord(fieldMap, record);
          record.setRecordLabel(formatRecordLabel(table, record));
       }
    }
 
 
 
+   /*******************************************************************************
+    ** For a list of records, set their recordLabels and display values
+    *******************************************************************************/
+   public static void setDisplayValuesInRecords(Collection<QFieldMetaData> fields, List<QRecord> records)
+   {
+      if(records == null)
+      {
+         return;
+      }
+
+      for(QRecord record : records)
+      {
+         setDisplayValuesInRecord(fields, record);
+      }
+   }
+
+
+
+   /*******************************************************************************
+    ** For a list of records, set their recordLabels and display values
+    *******************************************************************************/
+   public static void setDisplayValuesInRecords(Map<String, QFieldMetaData> fields, List<QRecord> records)
+   {
+      if(records == null)
+      {
+         return;
+      }
+
+      for(QRecord record : records)
+      {
+         setDisplayValuesInRecord(fields, record);
+      }
+   }
+
+
+
    /*******************************************************************************
     ** For a list of records, set their display values
     *******************************************************************************/
@@ -294,4 +398,168 @@ public class QValueFormatter
       }
    }
 
+
+
+   /*******************************************************************************
+    ** For a list of records, set their display values
+    *******************************************************************************/
+   public static void setDisplayValuesInRecord(Map<String, QFieldMetaData> fields, QRecord record)
+   {
+      for(Map.Entry<String, QFieldMetaData> entry : fields.entrySet())
+      {
+         String         fieldName = entry.getKey();
+         QFieldMetaData field     = entry.getValue();
+
+         if(record.getDisplayValue(fieldName) == null)
+         {
+            String formattedValue = formatValue(field, record.getValue(fieldName));
+            record.setDisplayValue(fieldName, formattedValue);
+         }
+      }
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public static String formatBoolean(Boolean b)
+   {
+      if(b == null)
+      {
+         return (null);
+      }
+      else if(b)
+      {
+         return ("Yes");
+      }
+      else
+      {
+         return ("No");
+      }
+   }
+
+
+
+   /*******************************************************************************
+    ** For any BLOB type fields in the list of records, change their value to
+    ** the URL where they can be downloaded, and set their display value to a file name.
+    *******************************************************************************/
+   public static void setBlobValuesToDownloadUrls(QTableMetaData table, List<QRecord> records)
+   {
+      for(QFieldMetaData field : table.getFields().values())
+      {
+         if(field.getType().equals(QFieldType.BLOB))
+         {
+            //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+            // file name comes from:                                                                                            //
+            // if there's a FILE_DOWNLOAD adornment, with a FILE_NAME_FIELD value, then the full filename comes from that field //
+            // - unless it was empty - then we do the "default thing":                                                          //
+            // else - the "default thing" is:                                                                                   //
+            // - tableLabel primaryKey fieldLabel                                                                               //
+            // - and - if the FILE_DOWNLOAD adornment had a DEFAULT_EXTENSION, then it gets added (preceded by a dot)           //
+            //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+            Optional<FieldAdornment>  fileDownloadAdornment = field.getAdornment(AdornmentType.FILE_DOWNLOAD);
+            Map<String, Serializable> adornmentValues       = Collections.emptyMap();
+
+            if(fileDownloadAdornment.isPresent())
+            {
+               adornmentValues = fileDownloadAdornment.get().getValues();
+            }
+
+            String fileNameField    = ValueUtils.getValueAsString(adornmentValues.get(AdornmentType.FileDownloadValues.FILE_NAME_FIELD));
+            String fileNameFormat   = ValueUtils.getValueAsString(adornmentValues.get(AdornmentType.FileDownloadValues.FILE_NAME_FORMAT));
+            String defaultExtension = ValueUtils.getValueAsString(adornmentValues.get(AdornmentType.FileDownloadValues.DEFAULT_EXTENSION));
+
+            for(QRecord record : records)
+            {
+               if(!doesFieldHaveValue(field, record))
+               {
+                  continue;
+               }
+
+               Serializable primaryKey = record.getValue(table.getPrimaryKeyField());
+               String       fileName   = null;
+
+               //////////////////////////////////////////////////
+               // try to make file name from the fileNameField //
+               //////////////////////////////////////////////////
+               if(StringUtils.hasContent(fileNameField))
+               {
+                  fileName = record.getValueString(fileNameField);
+               }
+
+               if(!StringUtils.hasContent(fileName))
+               {
+                  if(StringUtils.hasContent(fileNameFormat))
+                  {
+                     @SuppressWarnings("unchecked") // instance validation should make this safe!
+                     List<String> fileNameFormatFields = (List<String>) adornmentValues.get(AdornmentType.FileDownloadValues.FILE_NAME_FORMAT_FIELDS);
+                     List<String> values = fileNameFormatFields.stream().map(f -> ValueUtils.getValueAsString(record.getValue(f))).toList();
+                     fileName = QValueFormatter.formatStringWithValues(fileNameFormat, values);
+                  }
+               }
+
+               if(!StringUtils.hasContent(fileName))
+               {
+                  //////////////////////////////////
+                  // make default name if missing //
+                  //////////////////////////////////
+                  fileName = table.getLabel() + " " + primaryKey + " " + field.getLabel();
+
+                  if(StringUtils.hasContent(defaultExtension))
+                  {
+                     //////////////////////////////////////////
+                     // add default extension if we have one //
+                     //////////////////////////////////////////
+                     fileName += "." + defaultExtension;
+                  }
+               }
+
+               record.setValue(field.getName(), "/data/" + table.getName() + "/" + primaryKey + "/" + field.getName() + "/" + fileName);
+               record.setDisplayValue(field.getName(), fileName);
+            }
+         }
+      }
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private static boolean doesFieldHaveValue(QFieldMetaData field, QRecord record)
+   {
+      boolean fieldHasValue = false;
+
+      try
+      {
+         if(record.getValue(field.getName()) != null)
+         {
+            fieldHasValue = true;
+         }
+         else if(field.getIsHeavy())
+         {
+            /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+            // heavy fields that weren't fetched - they should have a backend-detail specifying their length (or null if null) //
+            /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+            Map<String, Serializable> heavyFieldLengths = (Map<String, Serializable>) record.getBackendDetail(QRecord.BACKEND_DETAILS_TYPE_HEAVY_FIELD_LENGTHS);
+            if(heavyFieldLengths != null)
+            {
+               Integer fieldLength = ValueUtils.getValueAsInteger(heavyFieldLengths.get(field.getName()));
+               if(fieldLength != null && fieldLength > 0)
+               {
+                  fieldHasValue = true;
+               }
+            }
+         }
+      }
+      catch(Exception e)
+      {
+         LOG.info("Error checking if field has value", e, logPair("fieldName", field.getName()), logPair("record", record));
+      }
+
+      return fieldHasValue;
+   }
+
 }

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

@@ -26,8 +26,10 @@ import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
+import com.kingsrook.qqq.backend.core.actions.customizers.QCodeLoader;
 import com.kingsrook.qqq.backend.core.actions.tables.QueryAction;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QCriteriaOperator;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QFilterCriteria;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QQueryFilter;
@@ -42,11 +44,10 @@ import com.kingsrook.qqq.backend.core.model.metadata.possiblevalues.QPossibleVal
 import com.kingsrook.qqq.backend.core.model.metadata.possiblevalues.QPossibleValueSource;
 import com.kingsrook.qqq.backend.core.model.metadata.possiblevalues.QPossibleValueSourceType;
 import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
+import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
 import com.kingsrook.qqq.backend.core.utils.StringUtils;
 import com.kingsrook.qqq.backend.core.utils.ValueUtils;
 import org.apache.commons.lang.NotImplementedException;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
 
 
 /*******************************************************************************
@@ -55,7 +56,7 @@ import org.apache.logging.log4j.Logger;
  *******************************************************************************/
 public class SearchPossibleValueSourceAction
 {
-   private static final Logger LOG = LogManager.getLogger(SearchPossibleValueSourceAction.class);
+   private static final QLogger LOG = QLogger.getLogger(SearchPossibleValueSourceAction.class);
 
    private QPossibleValueTranslator possibleValueTranslator;
 
@@ -105,13 +106,15 @@ public class SearchPossibleValueSourceAction
       SearchPossibleValueSourceOutput output      = new SearchPossibleValueSourceOutput();
       List<Serializable>              matchingIds = new ArrayList<>();
 
+      List<?> inputIdsAsCorrectType = convertInputIdsToEnumIdType(possibleValueSource, input.getIdList());
+
       for(QPossibleValue<?> possibleValue : possibleValueSource.getEnumValues())
       {
          boolean match = false;
 
          if(input.getIdList() != null)
          {
-            if(input.getIdList().contains(possibleValue.getId()))
+            if(inputIdsAsCorrectType.contains(possibleValue.getId()))
             {
                match = true;
             }
@@ -146,6 +149,44 @@ public class SearchPossibleValueSourceAction
 
 
 
+   /*******************************************************************************
+    ** The input list of ids might come through as a type that isn't the same as
+    ** the type of the ids in the enum (e.g., strings from a frontend, integers
+    ** in an enum).  So, this method looks at the first id in the enum, and then
+    ** maps all the inputIds to be of the same type.
+    *******************************************************************************/
+   private List<Object> convertInputIdsToEnumIdType(QPossibleValueSource possibleValueSource, List<Serializable> inputIdList)
+   {
+      List<Object> rs = new ArrayList<>();
+      if(CollectionUtils.nullSafeIsEmpty(inputIdList))
+      {
+         return (rs);
+      }
+
+      Object anIdFromTheEnum = possibleValueSource.getEnumValues().get(0).getId();
+
+      if(anIdFromTheEnum instanceof Integer)
+      {
+         inputIdList.forEach(id -> rs.add(ValueUtils.getValueAsInteger(id)));
+      }
+      else if(anIdFromTheEnum instanceof String)
+      {
+         inputIdList.forEach(id -> rs.add(ValueUtils.getValueAsString(id)));
+      }
+      else if(anIdFromTheEnum instanceof Boolean)
+      {
+         inputIdList.forEach(id -> rs.add(ValueUtils.getValueAsBoolean(id)));
+      }
+      else
+      {
+         LOG.warn("Unexpected type [" + anIdFromTheEnum.getClass().getSimpleName() + "] for ids in enum: " + possibleValueSource.getName());
+      }
+
+      return (rs);
+   }
+
+
+
    /*******************************************************************************
     **
     *******************************************************************************/
@@ -153,8 +194,7 @@ public class SearchPossibleValueSourceAction
    {
       SearchPossibleValueSourceOutput output = new SearchPossibleValueSourceOutput();
 
-      QueryInput queryInput = new QueryInput(input.getInstance());
-      queryInput.setSession(input.getSession());
+      QueryInput queryInput = new QueryInput();
       queryInput.setTableName(possibleValueSource.getTableName());
 
       QTableMetaData table = input.getInstance().getTable(possibleValueSource.getTableName());
@@ -204,10 +244,8 @@ public class SearchPossibleValueSourceAction
          }
       }
 
-      queryFilter.setOrderBys(possibleValueSource.getOrderByFields());
-
       // todo - skip & limit as params
-      queryInput.setLimit(250);
+      queryFilter.setLimit(250);
 
       ///////////////////////////////////////////////////////////////////////////////////////////////////////
       // if given a default filter, make it the 'top level' filter and the one we just created a subfilter //
@@ -217,6 +255,9 @@ public class SearchPossibleValueSourceAction
          input.getDefaultQueryFilter().addSubFilter(queryFilter);
          queryFilter = input.getDefaultQueryFilter();
       }
+
+      queryFilter.setOrderBys(possibleValueSource.getOrderByFields());
+
       queryInput.setFilter(queryFilter);
 
       QueryOutput             queryOutput     = new QueryAction().execute(queryInput);
@@ -236,8 +277,12 @@ public class SearchPossibleValueSourceAction
    {
       try
       {
-         // QCustomPossibleValueProvider customPossibleValueProvider = QCodeLoader.getCustomPossibleValueProvider(possibleValueSource);
-         // return (formatPossibleValue(possibleValueSource, customPossibleValueProvider.getPossibleValue(value)));
+         QCustomPossibleValueProvider customPossibleValueProvider = QCodeLoader.getCustomPossibleValueProvider(possibleValueSource);
+         List<QPossibleValue<?>>      possibleValues              = customPossibleValueProvider.search(input);
+
+         SearchPossibleValueSourceOutput output = new SearchPossibleValueSourceOutput();
+         output.setResults(possibleValues);
+         return (output);
       }
       catch(Exception e)
       {

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

@@ -29,6 +29,7 @@ import com.kingsrook.qqq.backend.core.model.metadata.fields.QFieldMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.fields.QFieldType;
 import com.kingsrook.qqq.backend.core.model.metadata.fields.ValueTooLongBehavior;
 import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
+import com.kingsrook.qqq.backend.core.model.statusmessages.BadInputStatusMessage;
 import com.kingsrook.qqq.backend.core.utils.StringUtils;
 
 
@@ -76,7 +77,7 @@ public class ValueBehaviorApplier
                {
                   case TRUNCATE -> record.setValue(fieldName, StringUtils.safeTruncate(value, field.getMaxLength()));
                   case TRUNCATE_ELLIPSIS -> record.setValue(fieldName, StringUtils.safeTruncate(value, field.getMaxLength(), "..."));
-                  case ERROR -> record.addError("The value for " + field.getLabel() + " is too long (max allowed length=" + field.getMaxLength() + ")");
+                  case ERROR -> record.addError(new BadInputStatusMessage("The value for " + field.getLabel() + " is too long (max allowed length=" + field.getMaxLength() + ")"));
                   case PASS_THROUGH ->
                   {
                   }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/adapters/CsvToQRecordAdapter.java

@@ -31,6 +31,7 @@ import java.util.List;
 import java.util.Map;
 import java.util.function.Consumer;
 import com.kingsrook.qqq.backend.core.actions.reporting.RecordPipe;
+import com.kingsrook.qqq.backend.core.exceptions.QException;
 import com.kingsrook.qqq.backend.core.model.actions.shared.mapping.AbstractQFieldMapping;
 import com.kingsrook.qqq.backend.core.model.data.QRecord;
 import com.kingsrook.qqq.backend.core.model.metadata.fields.QFieldMetaData;
@@ -61,7 +62,7 @@ public class CsvToQRecordAdapter
     ** using a given mapping.
     **
     *******************************************************************************/
-   public void buildRecordsFromCsv(RecordPipe recordPipe, String csv, QTableMetaData table, AbstractQFieldMapping<?> mapping, Consumer<QRecord> recordCustomizer)
+   public void buildRecordsFromCsv(RecordPipe recordPipe, String csv, QTableMetaData table, AbstractQFieldMapping<?> mapping, Consumer<QRecord> recordCustomizer) throws QException
    {
       buildRecordsFromCsv(new InputWrapper().withRecordPipe(recordPipe).withCsv(csv).withTable(table).withMapping(mapping).withRecordCustomizer(recordCustomizer));
    }
@@ -73,7 +74,7 @@ public class CsvToQRecordAdapter
     ** using a given mapping.
     **
     *******************************************************************************/
-   public List<QRecord> buildRecordsFromCsv(String csv, QTableMetaData table, AbstractQFieldMapping<?> mapping)
+   public List<QRecord> buildRecordsFromCsv(String csv, QTableMetaData table, AbstractQFieldMapping<?> mapping) throws QException
    {
       buildRecordsFromCsv(new InputWrapper().withCsv(csv).withTable(table).withMapping(mapping));
       return (recordList);
@@ -87,7 +88,7 @@ public class CsvToQRecordAdapter
     **
     ** todo - meta-data validation, type handling
     *******************************************************************************/
-   public void buildRecordsFromCsv(InputWrapper inputWrapper)
+   public void buildRecordsFromCsv(InputWrapper inputWrapper) throws QException
    {
       String                   csv              = inputWrapper.getCsv();
       AbstractQFieldMapping<?> mapping          = inputWrapper.getMapping();
@@ -297,7 +298,7 @@ public class CsvToQRecordAdapter
    /*******************************************************************************
     ** Add a record - either to the pipe, or list, whichever we're building.
     *******************************************************************************/
-   private void addRecord(QRecord record)
+   private void addRecord(QRecord record) throws QException
    {
       if(recordPipe != null)
       {

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/context/CapturedContext.java

@@ -0,0 +1,38 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2023.  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.context;
+
+
+import java.util.Stack;
+import com.kingsrook.qqq.backend.core.actions.QBackendTransaction;
+import com.kingsrook.qqq.backend.core.model.actions.AbstractActionInput;
+import com.kingsrook.qqq.backend.core.model.metadata.QInstance;
+import com.kingsrook.qqq.backend.core.model.session.QSession;
+
+
+/*******************************************************************************
+ ** record containing the values managed by QContext.
+ *******************************************************************************/
+public record CapturedContext(QInstance qInstance, QSession qSession, QBackendTransaction qBackendTransaction, Stack<AbstractActionInput> actionStack)
+{
+
+}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/context/QContext.java

@@ -0,0 +1,262 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2022.  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.context;
+
+
+import java.util.Optional;
+import java.util.Stack;
+import com.kingsrook.qqq.backend.core.actions.QBackendTransaction;
+import com.kingsrook.qqq.backend.core.exceptions.QInstanceValidationException;
+import com.kingsrook.qqq.backend.core.instances.QInstanceValidator;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
+import com.kingsrook.qqq.backend.core.model.actions.AbstractActionInput;
+import com.kingsrook.qqq.backend.core.model.metadata.QInstance;
+import com.kingsrook.qqq.backend.core.model.session.QSession;
+
+
+/*******************************************************************************
+ ** A collection of thread-local variables, to define the current context of the
+ ** QQQ code that is running.  e.g., what QInstance is being used, what QSession
+ ** is active, etc.
+ *******************************************************************************/
+public class QContext
+{
+   private static final QLogger LOG = QLogger.getLogger(QContext.class);
+
+   private static ThreadLocal<QInstance>                  qInstanceThreadLocal           = new ThreadLocal<>();
+   private static ThreadLocal<QSession>                   qSessionThreadLocal            = new ThreadLocal<>();
+   private static ThreadLocal<QBackendTransaction>        qBackendTransactionThreadLocal = new ThreadLocal<>();
+   private static ThreadLocal<Stack<AbstractActionInput>> actionStackThreadLocal         = new ThreadLocal<>();
+
+
+
+   /*******************************************************************************
+    ** private constructor - class is not meant to be instantiated.
+    *******************************************************************************/
+   private QContext()
+   {
+   }
+
+
+
+   /*******************************************************************************
+    ** Most common method to set or init the context - e.g., set the current thread
+    ** with a QInstance and QSession.
+    *******************************************************************************/
+   public static void init(QInstance qInstance, QSession qSession)
+   {
+      init(qInstance, qSession, null, null);
+   }
+
+
+
+   /*******************************************************************************
+    ** Full flavor init method - also take a transaction and action input (to seed the stack).
+    *******************************************************************************/
+   public static void init(QInstance qInstance, QSession qSession, QBackendTransaction transaction, AbstractActionInput actionInput)
+   {
+      qInstanceThreadLocal.set(qInstance);
+      qSessionThreadLocal.set(qSession);
+      qBackendTransactionThreadLocal.set(transaction);
+
+      actionStackThreadLocal.set(new Stack<>());
+      if(actionInput != null)
+      {
+         actionStackThreadLocal.get().add(actionInput);
+      }
+
+      if(qInstance != null && !qInstance.getHasBeenValidated())
+      {
+         try
+         {
+            new QInstanceValidator().validate(qInstance);
+         }
+         catch(QInstanceValidationException e)
+         {
+            LOG.warn(e);
+            throw (new IllegalArgumentException("QInstance failed validation" + e.getMessage(), e));
+         }
+      }
+   }
+
+
+
+   /*******************************************************************************
+    ** Init a new thread with the context captured from a different thread.  e.g.,
+    ** when starting some async task.
+    *******************************************************************************/
+   public static void init(CapturedContext capturedContext)
+   {
+      init(capturedContext.qInstance(), capturedContext.qSession(), capturedContext.qBackendTransaction(), null);
+      actionStackThreadLocal.set(capturedContext.actionStack());
+   }
+
+
+
+   /*******************************************************************************
+    ** Capture all values from the current thread - meant to be used with the init
+    ** overload that takes a CapturedContext, for setting up a child thread.
+    *******************************************************************************/
+   public static CapturedContext capture()
+   {
+      return (new CapturedContext(getQInstance(), getQSession(), getQBackendTransaction(), getActionStack()));
+   }
+
+
+
+   /*******************************************************************************
+    ** Clear all values in the current thread.
+    *******************************************************************************/
+   public static void clear()
+   {
+      qInstanceThreadLocal.remove();
+      qSessionThreadLocal.remove();
+      qBackendTransactionThreadLocal.remove();
+      actionStackThreadLocal.remove();
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public static QInstance getQInstance()
+   {
+      return (qInstanceThreadLocal.get());
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public static QSession getQSession()
+   {
+      return (qSessionThreadLocal.get());
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public static QBackendTransaction getQBackendTransaction()
+   {
+      return (qBackendTransactionThreadLocal.get());
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public static Stack<AbstractActionInput> getActionStack()
+   {
+      return (actionStackThreadLocal.get());
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public static void pushAction(AbstractActionInput action)
+   {
+      if(actionStackThreadLocal.get() == null)
+      {
+         actionStackThreadLocal.set(new Stack<>());
+      }
+      actionStackThreadLocal.get().push(action);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public static void popAction()
+   {
+      try
+      {
+         actionStackThreadLocal.get().pop();
+      }
+      catch(Exception e)
+      {
+         LOG.debug("Error popping action stack", e);
+      }
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public static void setQInstance(QInstance qInstance)
+   {
+      qInstanceThreadLocal.set(qInstance);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public static void setQSession(QSession qSession)
+   {
+      qSessionThreadLocal.set(qSession);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public static void setTransaction(QBackendTransaction transaction)
+   {
+      qBackendTransactionThreadLocal.set(transaction);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public static void clearTransaction()
+   {
+      qBackendTransactionThreadLocal.remove();
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public static Optional<AbstractActionInput> getFirstActionInStack()
+   {
+      if(actionStackThreadLocal.get() == null || actionStackThreadLocal.get().isEmpty())
+      {
+         return (Optional.empty());
+      }
+
+      return (Optional.of(actionStackThreadLocal.get().get(0)));
+   }
+}