Merge branch 'feature/CE-1107-add-day-by-day-views-for-the' into integration/sprint-40

docs/metaData/Joins.adoc

@@ -2,57 +2,16 @@
 == Joins
 include::../variables.adoc[]
 
-A `QJoinMetaData` is a meta-data object that tells QQQ, essentially “it is possible for these 2 tables to join, here’s how to do it”.
-
-Joins can be used then, in an application, in a number of possible ways:
-
-* In a {link-table}, we can specify joins to be “exposed”, e.g., made available to users on a query screen
-* Also in a Table, as part of an “Association”, which sets up one table as a “parent” of another,
-such that you can store (and fetch) the child-records at the same time as the parent
-** A common use-case here may be an order & lineItem table -
-such that QQQ can generate an API uses to allow you to post an order and its lines in a single request, and they get stored all together
-* In defining the security field (record lock) on a table,
-sometimes, it isn’t a field directly on the table, but instead comes from a joined table (possibly even more than just 1 table away).
-** For example, maybe a lineItem table, doesn't have a clientId, but needs secured by that field
-- so its recordLock can specify a “joinNameChain” that describes how to get from lineItem to order.clientId
-* The `QueryAction` can take (through its QueryInput object) zero or more QueryJoin objects,
-which must make a reference (implicitly or explicitly) to a QJoinMetaData.
-See the section on <<QueryJoin,QueryJoins>> for more details.
+#TODO#
 
 === QJoinMetaData
 Joins are defined in a QQQ Instance in a `*QJoinMetaData*` object.
 
-In this object, we have the concept of a "leftTable" and a "rightTable".
-There isn't generally anything special about which table is on the "left" and which is on the "right".
-But the remaining pieces of the QJoinMetaData do all need to line-up with these sides.
-
-For example:
-
-* The Type (one-to-one, one-to-many, many-to-one) - where the leftTable comes first, and rightTable comes second
-(e.g., a one-to-many means 1-row in leftTable has many-rows in rightTable associated with it)
-* In a JoinOn object, the 1st field name given is from the leftTable;
-the second fieldName from the rightTable.
+#TODO#
 
 *QJoinMetaData Properties:*
 
-* `name` - *String, Required* - Unique name for the join within the QQQ Instance.
-** One convention is to name joins based on (leftTable + "Join" + rightTable).
-** If you do not wish to define join names yourself, the method `withInferredName()`
-can be called (which defers to
-`public static String makeInferredJoinName(String leftTable, String rightTable)`),
-to create a name for the join following the (leftTable + "Join" + rightTable) convention.
-* `leftTable` - *String, Required* - Name of a {link-table} in the {link-instance}.
-* `rightTable` - *String, Required* - Name of a {link-table} in the {link-instance}.
-* `type` - *enum, Required* - cardinality between the two tables in the join.
-** e.g., `ONE_TO_ONE`, `ONE_TO_MANY` (indicating 1 record in the left table may join
-to many records in the right table), or `MANY_TO_ONE` (vice-versa).
-** Note that there is no MANY_TO_MANY option, as a many-to-many is built as multiple QJoinMetaData's
-going through the intermediary (intersection) table.
-* `joinOns` - *List<JoinOn>, Required* - fields used to join the tables.
-Note: In the 2-arg JoinOn constructor, the leftTable's field comes first.
-Alternatively, the no-arg constructor can be used along with `.withLeftField().withRightField()`
-* `orderBys` - *List<QFilterOrderBy>* - Optional list of order-by objects,
-used in some framework-generated queries using the join.
-The field names are assumed to come from the rightTable.
+* `name` - *String, Required* - Unique name for the join within the QQQ Instance. #todo infererences or conventions?#
+
+#TODO#
 
-#TODO# what else do we need here?

docs/metaData/Processes.adoc

@@ -16,7 +16,6 @@ Processes are defined in a QQQ Instance in a `*QProcessMetaData*` object.
 In addition to directly building a `QProcessMetaData` object setting its properties directly, there are a few common process patterns that provide *Builder* objects for ease-of-use.
 See StreamedETLWithFrontendProcess below for a common example
 
-[#_QProcessMetaData_Properties]
 *QProcessMetaData Properties:*
 
 * `name` - *String, Required* - Unique name for the process within the QQQ Instance.
@@ -31,13 +30,12 @@ See below for details.
 * `permissionRules` - *QPermissionRules object* - define the permission/access rules for the process.
 See {link-permissionRules} for details.
 * `steps` and `stepList` - *Map of String → <<QStepMetaData>>* and *List of QStepMetaData* - Defines the <<QFrontendStepMetaData,screens>> and <<QBackendStepMetaData,backend code>> that makes up the process.
-** `stepList` is the list of steps in the order that they will be executed
-(that is to say - this is the _default_ order of execution - but it can be customized - see <<_custom_process_flow>> for details).
-** `steps` is a map, including all steps from `stepList`, but which may also include steps which can used by the process if its backend steps make the decision to do so, at run-time (e.g., using <<_custom_process_flow>>).
+** `stepList` is the list of steps in the order that they will by default be executed.
+** `steps` is a map, including all steps from `stepList`, but which may also include steps which can used by the process if its backend steps make the decision to do so, at run-time.
 ** A process's steps are normally defined in one of two was:
 *** 1) by a single call to `.withStepList(List<QStepMetaData>)`, which internally adds each step into the `steps` map.
 *** 2) by multiple calls to `.addStep(QStepMetaData)`, which adds a step to both the `stepList` and `steps` map.
-** If a process also needs optional steps (for a <<_custom_process_flow>>), they should be added by a call to `.addOptionalStep(QStepMetaData)`, which only places them in the `steps` map.
+** If a process also needs optional steps, they should be added by a call to `.addOptionalStep(QStepMetaData)`, which only places them in the `steps` map.
 * `schedule` - *<<QScheduleMetaData>>* - set up the process to run automatically on the specified schedule.
 See below for details.
 * `minInputRecords` - *Integer* - #not used...#
@@ -216,112 +214,3 @@ But for some cases, doing page-level transactions can reduce long-transactions a
 * `withFields(List<QFieldMetaData> fieldList)` - Adds additional input fields to the preview step of the process.
 * `withBasepullConfiguration(BasepullConfiguration basepullConfiguration)` - Add a <<BasepullConfiguration>> to the process.
 * `withSchedule(QScheduleMetaData schedule)` - Add a <<QScheduleMetaData>> to the process.
-
-[#_custom_process_flow]
-==== Custom Process Flow
-As referenced in the definition of the <<_QProcessMetaData_Properties,QProcessMetaData Properties>>, by default, a process
-will execute each of its steps in-order, as defined in the `stepList` property.
-However, a Backend Step can customize this flow #todo - write more clearly here...
-
-There are generally 2 method to call (in a `BackendStep`) to do a dynamic flow:
-
-* `RunBackendStepOutput.setOverrideLastStepName(String stepName)`
-** QQQ's `RunProcessAction` keeps track of which step it "last" ran, e.g., to tell it which one to run next.
-However, if a step sets the `OverrideLastStepName` property in its output object,
-then the step named in that property becomes the effective "last" step,
-thus determining which step comes next.
-
-* `RunBackendStepOutput.updateStepList(List<String> stepNameList)`
-** Calling this method changes the process's runtime definition of steps to be executed.
-Thus allowing a completely custom flow.
-It should be noted, that the "last" step name (as tracked by QQQ within `RunProcessAction`)
-does need to be found in the new `stepNameList` - otherwise, the framework will not know where you were,
-for figuring out where to go next.
-
-[source,java]
-.Example of a defining process that can use a flexible flow:
-----
-// for a case like this, it would be recommended to define all step names in constants:
-public final static String STEP_START = "start";
-public final static String STEP_A     = "a";
-public final static String STEP_B     = "b";
-public final static String STEP_C     = "c";
-public final static String STEP_1     = "1";
-public final static String STEP_2     = "2";
-public final static String STEP_3     = "3";
-public final static String STEP_END   = "end";
-
-// also, to define the possible flows (lists of steps) in constants as well:
-public final static List<String> LETTERS_STEP_LIST = List.of(
-  STEP_START, STEP_A, STEP_B, STEP_C, STEP_END);
-
-public final static List<String> NUMBERS_STEP_LIST = List.of(
-  STEP_START, STEP_1, STEP_2, STEP_3, STEP_END);
-
-// when we define the process's meta-data, we only give a "skeleton" stepList -
-// we must at least have our starting step, and we may want at least one frontend step
-// for the UI to show some placeholder(s):
-QProcessMetaData process = new QProcessMetaData()
-   .withName(PROCESS_NAME)
-   .withStepList(List.of(
-      new QBackendStepMetaData().withName(STEP_START)
-         .withCode(new QCodeReference(/*...*/)),
-      new QFrontendStepMetaData()
-         .withName(STEP_END)
-   ));
-
-// the additional steps get added via `addOptionalStep`, which only puts them in
-// the process's stepMap, not its stepList!
-process.addOptionalStep(new QFrontendStepMetaData().withName(STEP_A));
-process.addOptionalStep(new QBackendStepMetaData().withName(STEP_B)
-   .withCode(new QCodeReference(/*...*/)));
-process.addOptionalStep(new QFrontendStepMetaData().withName(STEP_C));
-
-process.addOptionalStep(new QBackendStepMetaData().withName(STEP_1)
-   .withCode(new QCodeReference(/*...*/)));
-process.addOptionalStep(new QFrontendStepMetaData().withName(STEP_2));
-process.addOptionalStep(new QBackendStepMetaData().withName(STEP_3)
-   .withCode(new QCodeReference(/*...*/)));
-
-----
-
-[source,java]
-.Example of a process backend step adjusting the process's runtime flow:
-----
-/***************************************************************************
-** look at the value named "which". if it's "letters", then make the process
-** go through the stepList consisting of letters; else, update the step list
-** to be the "numbers" steps.
-**
-** Also - if the "skipSomeSteps" value is give as true, then set the
-** overrideLastStepName to skip again (in the letters case, skip past A, B
-** and C; in the numbers case, skip past 1 and 2).
-***************************************************************************/
-public static class StartStep implements BackendStep
-{
-  @Override
-  public void run(RunBackendStepInput runBackendStepInput, RunBackendStepOutput runBackendStepOutput) throws QException
-  {
-     Boolean skipSomeSteps = runBackendStepInput.getValueBoolean("skipSomeSteps");
-
-     if(runBackendStepInput.getValueString("which").equals("letters"))
-     {
-        runBackendStepOutput.updateStepList(LETTERS_STEP_LIST);
-        if(BooleanUtils.isTrue(skipSomeSteps))
-        {
-           runBackendStepOutput.setOverrideLastStepName(STEP_C);
-        }
-     }
-     else
-     {
-        runBackendStepOutput.updateStepList(NUMBERS_STEP_LIST);
-        if(BooleanUtils.isTrue(skipSomeSteps))
-        {
-           runBackendStepOutput.setOverrideLastStepName(STEP_2);
-        }
-     }
-  }
-}
-----
-
-

pom.xml

@@ -29,7 +29,6 @@
    <packaging>pom</packaging>
 
    <modules>
-      <module>qqq-bom</module>
       <module>qqq-backend-core</module>
       <module>qqq-backend-module-api</module>
       <module>qqq-backend-module-filesystem</module>
@@ -55,7 +54,7 @@
       <maven.compiler.showDeprecation>true</maven.compiler.showDeprecation>
       <maven.compiler.showWarnings>true</maven.compiler.showWarnings>
       <coverage.haltOnFailure>true</coverage.haltOnFailure>
-      <coverage.instructionCoveredRatioMinimum>0.75</coverage.instructionCoveredRatioMinimum>
+      <coverage.instructionCoveredRatioMinimum>0.80</coverage.instructionCoveredRatioMinimum>
       <coverage.classCoveredRatioMinimum>0.95</coverage.classCoveredRatioMinimum>
       <plugin.shade.phase>none</plugin.shade.phase>
    </properties>
@@ -150,7 +149,7 @@
                <dependency>
                   <groupId>com.puppycrawl.tools</groupId>
                   <artifactId>checkstyle</artifactId>
-                  <version>10.16.0</version>
+                  <version>9.0</version>
                </dependency>
             </dependencies>
             <executions>
@@ -246,7 +245,8 @@ echo "   See also target/site/jacoco/index.html"
 echo "   and https://www.jacoco.org/jacoco/trunk/doc/counters.html"
 echo "------------------------------------------------------------"
 
-if which xpath > /dev/null 2>&1; then
+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)}'
@@ -255,7 +255,8 @@ else
    echo "xpath is not installed.  Jacoco coverage summary will not be produced here...";
 fi
 
-if which html2text > /dev/null 2>&1; then
+which xpath > /dev/null 2>&1
+if [ "$?" == "0" ]; then
    echo "Untested classes, per Jacoco:"
    echo "-----------------------------"
    for i in target/site/jacoco/*/index.html; do

qqq-backend-core/pom.xml

@@ -173,19 +173,6 @@
          <version>1.12.321</version>
       </dependency>
 
-      <dependency>
-         <groupId>com.amazonaws</groupId>
-         <artifactId>aws-java-sdk-ses</artifactId>
-         <version>1.12.705</version>
-      </dependency>
-
-      <dependency>
-         <groupId>cloud.localstack</groupId>
-         <artifactId>localstack-utils</artifactId>
-         <version>0.2.20</version>
-         <scope>test</scope>
-      </dependency>
-
       <dependency>
          <groupId>org.quartz-scheduler</groupId>
          <artifactId>quartz</artifactId>
@@ -199,12 +186,6 @@
          <version>2.23.0</version>
       </dependency>
 
-      <dependency>
-         <groupId>com.sun.mail</groupId>
-         <artifactId>jakarta.mail</artifactId>
-         <version>2.0.1</version>
-      </dependency>
-
       <!-- Common deps for all qqq modules -->
       <dependency>
          <groupId>org.apache.maven.plugins</groupId>

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

@@ -54,9 +54,9 @@ public class NonPersistedAsyncJobCallback extends AsyncJobCallback
    @Override
    protected void storeUpdatedStatus()
    {
-      ///////////////////////////////////////////////////////////////////////////////////////
-      // noop - cf. base class, which writes to persistence here (our point is, we do not) //
-      ///////////////////////////////////////////////////////////////////////////////////////
+      //////////
+      // noop //
+      //////////
    }
 
 }

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

@@ -149,7 +149,7 @@ public class DMLAuditAction extends AbstractQActionFunction<DMLAuditInput, DMLAu
             // sort the field names by their labels //
             //////////////////////////////////////////
             List<String> sortedFieldNames = table.getFields().keySet().stream()
-               .sorted(Comparator.comparing(fieldName -> Objects.requireNonNullElse(table.getFields().get(fieldName).getLabel(), fieldName)))
+               .sorted(Comparator.comparing(fieldName -> table.getFields().get(fieldName).getLabel()))
                .toList();
 
             QFieldMetaData primaryKeyField = table.getField(table.getPrimaryKeyField());

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

@@ -127,6 +127,7 @@ public enum AutomationStatus implements PossibleValueEnum<Integer>
    /*******************************************************************************
     **
     *******************************************************************************/
+   @SuppressWarnings("checkstyle:indentation")
    public String getInsertOrUpdate()
    {
       return switch(this)

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

@@ -50,7 +50,10 @@ public interface RecordCustomizerUtilityInterface
    /*******************************************************************************
     ** Container for an old value and a new value.
     *******************************************************************************/
-   record Change(Serializable oldValue, Serializable newValue) {}
+   @SuppressWarnings("checkstyle:MethodName")
+   record Change(Serializable oldValue, Serializable newValue)
+   {
+   }
 
 
    /*******************************************************************************

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

@@ -161,7 +161,7 @@ public abstract class AbstractHTMLWidgetRenderer extends AbstractWidgetRenderer
    public static String linkTableCreateWithDefaultValues(RenderWidgetInput input, String tableName, Map<String, Serializable> defaultValues) throws QException
    {
       String tablePath = QContext.getQInstance().getTablePath(tableName);
-      return (tablePath + "/create#defaultValues=" + URLEncoder.encode(JsonUtils.toJson(defaultValues), Charset.defaultCharset()));
+      return (tablePath + "/create?defaultValues=" + URLEncoder.encode(JsonUtils.toJson(defaultValues), Charset.defaultCharset()));
    }
 
 
@@ -183,6 +183,7 @@ public abstract class AbstractHTMLWidgetRenderer extends AbstractWidgetRenderer
 
 
 
+
    /*******************************************************************************
     **
     *******************************************************************************/

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

@@ -36,7 +36,6 @@ 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.logging.QLogger;
 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;
@@ -60,7 +59,6 @@ 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;
-import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
 
 
 /*******************************************************************************
@@ -68,9 +66,6 @@ import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
  *******************************************************************************/
 public class ChildRecordListRenderer extends AbstractWidgetRenderer
 {
-   private static final QLogger LOG = QLogger.getLogger(ChildRecordListRenderer.class);
-
-
 
    /*******************************************************************************
     **
@@ -177,134 +172,126 @@ public class ChildRecordListRenderer extends AbstractWidgetRenderer
    @Override
    public RenderWidgetOutput render(RenderWidgetInput input) throws QException
    {
-      try
+      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")))
       {
-         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());
+         maxRows = ValueUtils.getValueAsInteger(input.getQueryParams().get("maxRows"));
+      }
+      else if(input.getWidgetMetaData().getDefaultValues().containsKey("maxRows"))
+      {
+         maxRows = ValueUtils.getValueAsInteger(input.getWidgetMetaData().getDefaultValues().containsKey("maxRows"));
+      }
 
-         Integer maxRows = null;
-         if(StringUtils.hasContent(input.getQueryParams().get("maxRows")))
+      //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // fetch the record that we're getting children for. e.g., the left-side of the join, with the input id                                     //
+      // but - only try this if we were given an id.  note, this widget could be called for on an INSERT screen, where we don't have a record yet //
+      // but we still want to be able to return all the other data in here that otherwise comes from the widget meta data, join, etc.             //
+      //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      int          totalRows     = 0;
+      QRecord      primaryRecord = null;
+      QQueryFilter filter        = null;
+      QueryOutput  queryOutput   = new QueryOutput(new QueryInput());
+      if(StringUtils.hasContent(id))
+      {
+         GetInput getInput = new GetInput();
+         getInput.setTableName(join.getLeftTable());
+         getInput.setPrimaryKey(id);
+         GetOutput getOutput = new GetAction().execute(getInput);
+         primaryRecord = getOutput.getRecord();
+
+         if(primaryRecord == null)
          {
-            maxRows = ValueUtils.getValueAsInteger(input.getQueryParams().get("maxRows"));
-         }
-         else if(input.getWidgetMetaData().getDefaultValues().containsKey("maxRows"))
-         {
-            maxRows = ValueUtils.getValueAsInteger(input.getWidgetMetaData().getDefaultValues().containsKey("maxRows"));
+            throw (new QNotFoundException("Could not find " + (leftTable == null ? "" : leftTable.getLabel()) + " with primary key " + id));
          }
 
-         //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-         // fetch the record that we're getting children for. e.g., the left-side of the join, with the input id                                     //
-         // but - only try this if we were given an id.  note, this widget could be called for on an INSERT screen, where we don't have a record yet //
-         // but we still want to be able to return all the other data in here that otherwise comes from the widget meta data, join, etc.             //
-         //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-         int          totalRows     = 0;
-         QRecord      primaryRecord = null;
-         QQueryFilter filter        = null;
-         QueryOutput  queryOutput   = new QueryOutput(new QueryInput());
-         if(StringUtils.hasContent(id))
+         ////////////////////////////////////////////////////////////////////
+         // set up the query - for the table on the right side of the join //
+         ////////////////////////////////////////////////////////////////////
+         filter = new QQueryFilter();
+         for(JoinOn joinOn : join.getJoinOns())
          {
-            GetInput getInput = new GetInput();
-            getInput.setTableName(join.getLeftTable());
-            getInput.setPrimaryKey(id);
-            GetOutput getOutput = new GetAction().execute(getInput);
-            primaryRecord = getOutput.getRecord();
+            filter.addCriteria(new QFilterCriteria(joinOn.getRightField(), QCriteriaOperator.EQUALS, List.of(primaryRecord.getValue(joinOn.getLeftField()))));
+         }
+         filter.setOrderBys(join.getOrderBys());
+         filter.setLimit(maxRows);
 
-            if(primaryRecord == null)
-            {
-               throw (new QNotFoundException("Could not find " + (leftTable == null ? "" : leftTable.getLabel()) + " with primary key " + id));
-            }
+         QueryInput queryInput = new QueryInput();
+         queryInput.setTableName(join.getRightTable());
+         queryInput.setShouldTranslatePossibleValues(true);
+         queryInput.setShouldGenerateDisplayValues(true);
+         queryInput.setFilter(filter);
+         queryOutput = new QueryAction().execute(queryInput);
 
-            ////////////////////////////////////////////////////////////////////
-            // set up the query - for the table on the right side of the join //
-            ////////////////////////////////////////////////////////////////////
-            filter = new QQueryFilter();
+         QValueFormatter.setBlobValuesToDownloadUrls(rightTable, queryOutput.getRecords());
+
+         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"))))
+      {
+         widgetData.setCanAddChildRecord(true);
+
+         //////////////////////////////////////////////////////////
+         // new child records must have values from the join-ons //
+         //////////////////////////////////////////////////////////
+         Map<String, Serializable> defaultValuesForNewChildRecords = new HashMap<>();
+         if(primaryRecord != null)
+         {
             for(JoinOn joinOn : join.getJoinOns())
             {
-               filter.addCriteria(new QFilterCriteria(joinOn.getRightField(), QCriteriaOperator.EQUALS, List.of(primaryRecord.getValue(joinOn.getLeftField()))));
-            }
-            filter.setOrderBys(join.getOrderBys());
-            filter.setLimit(maxRows);
-
-            QueryInput queryInput = new QueryInput();
-            queryInput.setTableName(join.getRightTable());
-            queryInput.setShouldTranslatePossibleValues(true);
-            queryInput.setShouldGenerateDisplayValues(true);
-            queryInput.setFilter(filter);
-            queryOutput = new QueryAction().execute(queryInput);
-
-            QValueFormatter.setBlobValuesToDownloadUrls(rightTable, queryOutput.getRecords());
-
-            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();
+               defaultValuesForNewChildRecords.put(joinOn.getRightField(), primaryRecord.getValue(joinOn.getLeftField()));
             }
          }
 
-         String tablePath   = input.getInstance().getTablePath(rightTable.getName());
-         String viewAllLink = tablePath == null ? null : (tablePath + "?filter=" + URLEncoder.encode(JsonUtils.toJson(filter), Charset.defaultCharset()));
+         widgetData.setDefaultValuesForNewChildRecords(defaultValuesForNewChildRecords);
 
-         ChildRecordListData widgetData = new ChildRecordListData(widgetLabel, queryOutput, rightTable, tablePath, viewAllLink, totalRows);
-
-         if(BooleanUtils.isTrue(ValueUtils.getValueAsBoolean(input.getQueryParams().get("canAddChildRecord"))))
+         Map<String, Serializable> widgetValues = input.getWidgetMetaData().getDefaultValues();
+         if(widgetValues.containsKey("disabledFieldsForNewChildRecords"))
          {
-            widgetData.setCanAddChildRecord(true);
-
-            //////////////////////////////////////////////////////////
-            // new child records must have values from the join-ons //
-            //////////////////////////////////////////////////////////
-            Map<String, Serializable> defaultValuesForNewChildRecords = new HashMap<>();
-            if(primaryRecord != null)
+            widgetData.setDisabledFieldsForNewChildRecords((Set<String>) widgetValues.get("disabledFieldsForNewChildRecords"));
+         }
+         else
+         {
+            /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+            // if there are no disabled fields specified - then normally any fields w/ a default value get implicitly disabled //
+            // but - if we didn't look-up the primary record, then we'll want to explicit disable fields from joins            //
+            /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+            if(primaryRecord == null)
             {
+               Set<String> implicitlyDisabledFields = new HashSet<>();
+               widgetData.setDisabledFieldsForNewChildRecords(implicitlyDisabledFields);
                for(JoinOn joinOn : join.getJoinOns())
                {
-                  defaultValuesForNewChildRecords.put(joinOn.getRightField(), primaryRecord.getValue(joinOn.getLeftField()));
-               }
-            }
-
-            widgetData.setDefaultValuesForNewChildRecords(defaultValuesForNewChildRecords);
-
-            Map<String, Serializable> widgetValues = input.getWidgetMetaData().getDefaultValues();
-            if(widgetValues.containsKey("disabledFieldsForNewChildRecords"))
-            {
-               widgetData.setDisabledFieldsForNewChildRecords((Set<String>) widgetValues.get("disabledFieldsForNewChildRecords"));
-            }
-            else
-            {
-               /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-               // if there are no disabled fields specified - then normally any fields w/ a default value get implicitly disabled //
-               // but - if we didn't look-up the primary record, then we'll want to explicit disable fields from joins            //
-               /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-               if(primaryRecord == null)
-               {
-                  Set<String> implicitlyDisabledFields = new HashSet<>();
-                  widgetData.setDisabledFieldsForNewChildRecords(implicitlyDisabledFields);
-                  for(JoinOn joinOn : join.getJoinOns())
-                  {
-                     implicitlyDisabledFields.add(joinOn.getRightField());
-                  }
+                  implicitlyDisabledFields.add(joinOn.getRightField());
                }
             }
          }
+      }
 
-         return (new RenderWidgetOutput(widgetData));
-      }
-      catch(Exception e)
-      {
-         LOG.warn("Error rendering child record list", e, logPair("widgetName", () -> input.getWidgetMetaData().getName()));
-         throw (e);
-      }
+      return (new RenderWidgetOutput(widgetData));
    }
 
 }

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

@@ -256,6 +256,7 @@ public enum DateTimeGroupBy
    /*******************************************************************************
     **
     *******************************************************************************/
+   @SuppressWarnings("checkstyle:indentation")
    public Instant roundDown(Instant instant, ZoneId zoneId)
    {
       ZonedDateTime zoned = instant.atZone(zoneId);

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

@@ -1,86 +0,0 @@
-/*
- * QQQ - Low-code Application Framework for Engineers.
- * Copyright (C) 2021-2024.  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 com.kingsrook.qqq.backend.core.exceptions.QException;
-import com.kingsrook.qqq.backend.core.model.MetaDataProducerInterface;
-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.AlertData;
-import com.kingsrook.qqq.backend.core.model.dashboard.widgets.WidgetType;
-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.dashboard.QWidgetMetaData;
-
-
-/*******************************************************************************
- ** Widget that can add an Alert to a process screen.
- **
- ** In the process, you'll want values:
- ** - alertType - name of entry in AlertType enum (ERROR, WARNING, SUCCESS)
- ** - alertHtml - html to display inside the alert (other than its icon)
- *******************************************************************************/
-public class ProcessAlertWidget extends AbstractWidgetRenderer implements MetaDataProducerInterface<QWidgetMetaData>
-{
-   public static final String NAME = "ProcessAlertWidget";
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   @Override
-   public RenderWidgetOutput render(RenderWidgetInput input) throws QException
-   {
-      AlertData.AlertType alertType = AlertData.AlertType.WARNING;
-      if(input.getQueryParams().containsKey("alertType"))
-      {
-         alertType = AlertData.AlertType.valueOf(input.getQueryParams().get("alertType"));
-      }
-
-      String html = "Warning";
-      if(input.getQueryParams().containsKey("alertHtml"))
-      {
-         html = input.getQueryParams().get("alertHtml");
-      }
-
-      return (new RenderWidgetOutput(new AlertData(alertType, html)));
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   @Override
-   public QWidgetMetaData produce(QInstance qInstance) throws QException
-   {
-      return new QWidgetMetaData()
-         .withType(WidgetType.ALERT.getType())
-         .withGridColumns(12)
-         .withName(NAME)
-         .withIsCard(false)
-         .withShowReloadButton(false)
-         .withCodeReference(new QCodeReference(getClass()));
-   }
-}

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

@@ -30,7 +30,7 @@ import com.kingsrook.qqq.backend.core.model.actions.tables.storage.StorageInput;
 
 /*******************************************************************************
  ** Interface for actions that a backend can perform, based on streaming data
- ** into the backend's storage.
+ ** into the backend's storage. 
  *******************************************************************************/
 public interface QStorageInterface
 {
@@ -46,24 +46,4 @@ public interface QStorageInterface
     *******************************************************************************/
    InputStream getInputStream(StorageInput storageInput) throws QException;
 
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   default void makePublic(StorageInput storageInput) throws QException
-   {
-      //////////
-      // noop //
-      //////////
-   }
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   default String getDownloadURL(StorageInput storageInput) throws QException
-   {
-      return (null);
-   }
-
 }

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

@@ -1,64 +0,0 @@
-/*
- * QQQ - Low-code Application Framework for Engineers.
- * Copyright (C) 2021-2024.  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.messaging;
-
-
-import com.kingsrook.qqq.backend.core.actions.AbstractQActionFunction;
-import com.kingsrook.qqq.backend.core.context.QContext;
-import com.kingsrook.qqq.backend.core.exceptions.QException;
-import com.kingsrook.qqq.backend.core.model.actions.messaging.SendMessageInput;
-import com.kingsrook.qqq.backend.core.model.actions.messaging.SendMessageOutput;
-import com.kingsrook.qqq.backend.core.model.metadata.messaging.QMessagingProviderMetaData;
-import com.kingsrook.qqq.backend.core.modules.messaging.MessagingProviderInterface;
-import com.kingsrook.qqq.backend.core.modules.messaging.QMessagingProviderDispatcher;
-import com.kingsrook.qqq.backend.core.utils.StringUtils;
-
-
-/*******************************************************************************
- **
- *******************************************************************************/
-public class SendMessageAction extends AbstractQActionFunction<SendMessageInput, SendMessageOutput>
-{
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   @Override
-   public SendMessageOutput execute(SendMessageInput input) throws QException
-   {
-      if(!StringUtils.hasContent(input.getMessagingProviderName()))
-      {
-         throw (new QException("Messaging provider name was not given in SendMessageInput."));
-      }
-
-      QMessagingProviderMetaData messagingProvider = QContext.getQInstance().getMessagingProvider(input.getMessagingProviderName());
-      if(messagingProvider == null)
-      {
-         throw (new QException("Messaging provider named [" + input.getMessagingProviderName() + "] was not found in this QInstance."));
-      }
-
-      MessagingProviderInterface messagingProviderInterface = new QMessagingProviderDispatcher().getMessagingProviderInterface(messagingProvider.getType());
-
-      return (messagingProviderInterface.sendMessage(input));
-   }
-
-}

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

@@ -29,7 +29,6 @@ import java.util.List;
 import java.util.Objects;
 import java.util.Set;
 import java.util.TreeSet;
-import com.kingsrook.qqq.backend.core.instances.QMetaDataVariableInterpreter;
 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;
@@ -42,18 +41,8 @@ import com.kingsrook.qqq.backend.core.utils.StringUtils;
  *******************************************************************************/
 public class JoinGraph
 {
-   private Set<Edge> edges = new HashSet<>();
 
-   ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-   // as an instance grows, with the number of joins (say, more than 50?), especially as they may have a lot of connections, //
-   // it can become very very slow to process a full join graph (e.g., 10 seconds, maybe much worse, per Big-O...)           //
-   // also, it's not frequently useful to look at a join path that's more than a handful of tables long.                     //
-   // thus - this property exists - to limit the max length of a join path.  Keeping it small keeps instance enrichment      //
-   // and validation reasonably performant, at the possible cost of, some join-path that's longer than this limit may not    //
-   // be found - but - chances are, you don't want some 12-element join path to be used anyway, thus, this makes sense.      //
-   // but - it can be adjusted, per system property or ENV var.                                                              //
-   ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-   private int maxPathLength = new QMetaDataVariableInterpreter().getIntegerFromPropertyOrEnvironment("qqq.instance.joinGraph.maxPathLength", "QQQ_INSTANCE_JOIN_GRAPH_MAX_PATH_LENGTH", 3);
+   private Set<Edge> edges = new HashSet<>();
 
 
 
@@ -314,13 +303,6 @@ public class JoinGraph
 
                if(otherTableName != null)
                {
-                  if(newPath.size() > maxPathLength)
-                  {
-                     ////////////////////////////////////////////////////////////////
-                     // performance hack.  see comment at maxPathLength definition //
-                     ////////////////////////////////////////////////////////////////
-                     continue;
-                  }
 
                   JoinConnectionList newConnectionList = connectionList.copy();
                   JoinConnection     joinConnection    = new JoinConnection(otherTableName, edge.joinName);

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

@@ -500,6 +500,7 @@ public class PermissionsHelper
    /*******************************************************************************
     **
     *******************************************************************************/
+   @SuppressWarnings("checkstyle:indentation")
    static PermissionSubType getEffectivePermissionSubType(QPermissionRules rules, PermissionSubType originalPermissionSubType)
    {
       if(rules == null || rules.getLevel() == null)
@@ -514,10 +515,10 @@ public class PermissionsHelper
       if(PrivatePermissionSubType.HAS_ACCESS.equals(originalPermissionSubType))
       {
          return switch(rules.getLevel())
-         {
-            case NOT_PROTECTED -> null;
-            default -> PrivatePermissionSubType.HAS_ACCESS;
-         };
+            {
+               case NOT_PROTECTED -> null;
+               default -> PrivatePermissionSubType.HAS_ACCESS;
+            };
       }
       else
       {
@@ -526,30 +527,30 @@ public class PermissionsHelper
          // permission sub-type to what we expect to be set for the table                                      //
          ////////////////////////////////////////////////////////////////////////////////////////////////////////
          return switch(rules.getLevel())
-         {
-            case NOT_PROTECTED -> null;
-            case HAS_ACCESS_PERMISSION -> PrivatePermissionSubType.HAS_ACCESS;
-            case READ_WRITE_PERMISSIONS ->
             {
-               if(PrivatePermissionSubType.READ.equals(originalPermissionSubType) || PrivatePermissionSubType.WRITE.equals(originalPermissionSubType))
+               case NOT_PROTECTED -> null;
+               case HAS_ACCESS_PERMISSION -> PrivatePermissionSubType.HAS_ACCESS;
+               case READ_WRITE_PERMISSIONS ->
                {
-                  yield (originalPermissionSubType);
+                  if(PrivatePermissionSubType.READ.equals(originalPermissionSubType) || PrivatePermissionSubType.WRITE.equals(originalPermissionSubType))
+                  {
+                     yield (originalPermissionSubType);
+                  }
+                  else if(TablePermissionSubType.INSERT.equals(originalPermissionSubType) || TablePermissionSubType.EDIT.equals(originalPermissionSubType) || TablePermissionSubType.DELETE.equals(originalPermissionSubType))
+                  {
+                     yield (PrivatePermissionSubType.WRITE);
+                  }
+                  else if(TablePermissionSubType.READ.equals(originalPermissionSubType))
+                  {
+                     yield (PrivatePermissionSubType.READ);
+                  }
+                  else
+                  {
+                     throw new IllegalStateException("Unexpected permissionSubType: " + originalPermissionSubType);
+                  }
                }
-               else if(TablePermissionSubType.INSERT.equals(originalPermissionSubType) || TablePermissionSubType.EDIT.equals(originalPermissionSubType) || TablePermissionSubType.DELETE.equals(originalPermissionSubType))
-               {
-                  yield (PrivatePermissionSubType.WRITE);
-               }
-               else if(TablePermissionSubType.READ.equals(originalPermissionSubType))
-               {
-                  yield (PrivatePermissionSubType.READ);
-               }
-               else
-               {
-                  throw new IllegalStateException("Unexpected permissionSubType: " + originalPermissionSubType);
-               }
-            }
-            case READ_INSERT_EDIT_DELETE_PERMISSIONS -> originalPermissionSubType;
-         };
+               case READ_INSERT_EDIT_DELETE_PERMISSIONS -> originalPermissionSubType;
+            };
       }
    }
 

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

@@ -1,110 +0,0 @@
-/*
- * 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.processes;
-
-
-import java.util.Optional;
-import java.util.UUID;
-import com.kingsrook.qqq.backend.core.actions.ActionHelper;
-import com.kingsrook.qqq.backend.core.exceptions.QBadRequestException;
-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.RunProcessInput;
-import com.kingsrook.qqq.backend.core.model.actions.processes.RunProcessOutput;
-import com.kingsrook.qqq.backend.core.model.metadata.processes.QProcessMetaData;
-import com.kingsrook.qqq.backend.core.state.StateType;
-import com.kingsrook.qqq.backend.core.state.UUIDAndTypeStateKey;
-import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
-
-
-/*******************************************************************************
- ** Action handler for running the cancel step of a qqq process
- *
- *******************************************************************************/
-public class CancelProcessAction extends RunProcessAction
-{
-   private static final QLogger LOG = QLogger.getLogger(CancelProcessAction.class);
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   public RunProcessOutput execute(RunProcessInput runProcessInput) throws QException
-   {
-      ActionHelper.validateSession(runProcessInput);
-
-      QProcessMetaData process = runProcessInput.getInstance().getProcess(runProcessInput.getProcessName());
-      if(process == null)
-      {
-         throw new QBadRequestException("Process [" + runProcessInput.getProcessName() + "] is not defined in this instance.");
-      }
-
-      if(runProcessInput.getProcessUUID() == null)
-      {
-         throw (new QBadRequestException("Cannot cancel process - processUUID was not given."));
-      }
-
-      UUIDAndTypeStateKey    stateKey     = new UUIDAndTypeStateKey(UUID.fromString(runProcessInput.getProcessUUID()), StateType.PROCESS_STATUS);
-      Optional<ProcessState> processState = getState(runProcessInput.getProcessUUID());
-      if(processState.isEmpty())
-      {
-         throw (new QBadRequestException("Cannot cancel process - State for process UUID [" + runProcessInput.getProcessUUID() + "] was not found."));
-      }
-
-      RunProcessOutput runProcessOutput = new RunProcessOutput();
-      try
-      {
-         if(process.getCancelStep() != null)
-         {
-            LOG.info("Running cancel step for process", logPair("processName", process.getName()));
-            runBackendStep(runProcessInput, process, runProcessOutput, stateKey, process.getCancelStep(), process, processState.get());
-         }
-         else
-         {
-            LOG.debug("Process does not have a custom cancel step to run.", logPair("processName", process.getName()));
-         }
-      }
-      catch(QException qe)
-      {
-         ////////////////////////////////////////////////////////////
-         // upon exception (e.g., one thrown by a step), throw it. //
-         ////////////////////////////////////////////////////////////
-         throw (qe);
-      }
-      catch(Exception e)
-      {
-         throw (new QException("Error cancelling process", e));
-      }
-      finally
-      {
-         //////////////////////////////////////////////////////
-         // always put the final state in the process result //
-         //////////////////////////////////////////////////////
-         runProcessOutput.setProcessState(processState.get());
-      }
-
-      return (runProcessOutput);
-   }
-
-}

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

@@ -23,7 +23,6 @@ package com.kingsrook.qqq.backend.core.actions.processes;
 
 
 import java.io.Serializable;
-import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
@@ -115,14 +114,4 @@ public class QProcessCallbackFactory
       return (forFilter(new QQueryFilter().withCriteria(new QFilterCriteria(fieldName, QCriteriaOperator.EQUALS, value))));
    }
 
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   public static QProcessCallback forPrimaryKeys(String fieldName, Collection<? extends Serializable> values)
-   {
-      return (forFilter(new QQueryFilter().withCriteria(new QFilterCriteria(fieldName, QCriteriaOperator.IN, values))));
-   }
-
 }

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

@@ -26,7 +26,6 @@ import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
-import java.util.Objects;
 import java.util.stream.Collectors;
 import com.kingsrook.qqq.backend.core.actions.ActionHelper;
 import com.kingsrook.qqq.backend.core.actions.tables.QueryAction;
@@ -35,7 +34,6 @@ 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.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.metadata.code.QCodeReference;
@@ -73,17 +71,7 @@ public class RunBackendStepAction
       QStepMetaData stepMetaData = process.getStep(runBackendStepInput.getStepName());
       if(stepMetaData == null)
       {
-         if(process.getCancelStep() != null && Objects.equals(process.getCancelStep().getName(), runBackendStepInput.getStepName()))
-         {
-            /////////////////////////////////////
-            // special case for cancel step... //
-            /////////////////////////////////////
-            stepMetaData = process.getCancelStep();
-         }
-         else
-         {
-            throw new QException("Step [" + runBackendStepInput.getStepName() + "] is not defined in the process [" + process.getName() + "]");
-         }
+         throw new QException("Step [" + runBackendStepInput.getStepName() + "] is not defined in the process [" + process.getName() + "]");
       }
 
       if(!(stepMetaData instanceof QBackendStepMetaData backendStepMetaData))
@@ -94,7 +82,7 @@ public class RunBackendStepAction
       //////////////////////////////////////////////////////////////////////////////////////
       // ensure input data is set as needed - use callback object to get anything missing //
       //////////////////////////////////////////////////////////////////////////////////////
-      ensureRecordsAreInRequest(runBackendStepInput, backendStepMetaData, process);
+      ensureRecordsAreInRequest(runBackendStepInput, backendStepMetaData);
       ensureInputFieldsAreInRequest(runBackendStepInput, backendStepMetaData);
 
       ////////////////////////////////////////////////////////////////////
@@ -179,7 +167,7 @@ public class RunBackendStepAction
     ** check if this step uses a record list - and if so, if we need to get one
     ** via the callback
     *******************************************************************************/
-   private void ensureRecordsAreInRequest(RunBackendStepInput runBackendStepInput, QBackendStepMetaData step, QProcessMetaData process) throws QException
+   private void ensureRecordsAreInRequest(RunBackendStepInput runBackendStepInput, QBackendStepMetaData step) throws QException
    {
       QFunctionInputMetaData inputMetaData = step.getInputMetaData();
       if(inputMetaData != null && inputMetaData.getRecordListMetaData() != null)
@@ -202,44 +190,9 @@ public class RunBackendStepAction
 
             queryInput.setFilter(callback.getQueryFilter());
 
-            //////////////////////////////////////////////////////////////////////////////////////////
-            // if process has a max-no of records, set a limit on the process of that number plus 1 //
-            // (the plus 1 being so we can see "oh, you selected more than that many; error!"       //
-            //////////////////////////////////////////////////////////////////////////////////////////
-            if(process.getMaxInputRecords() != null)
-            {
-               if(callback.getQueryFilter() == null)
-               {
-                  queryInput.setFilter(new QQueryFilter());
-               }
-
-               queryInput.getFilter().setLimit(process.getMaxInputRecords() + 1);
-            }
-
             QueryOutput queryOutput = new QueryAction().execute(queryInput);
             runBackendStepInput.setRecords(queryOutput.getRecords());
-
-            ////////////////////////////////////////////////////////////////////////////////
-            // if process defines a max, and more than the max were found, throw an error //
-            ////////////////////////////////////////////////////////////////////////////////
-            if(process.getMaxInputRecords() != null)
-            {
-               if(queryOutput.getRecords().size() > process.getMaxInputRecords())
-               {
-                  throw (new QUserFacingException("Too many records were selected for this process.  At most, only " + process.getMaxInputRecords() + " can be selected."));
-               }
-            }
-
-            /////////////////////////////////////////////////////////////////////////////////
-            // if process defines a min, and fewer than the min were found, throw an error //
-            /////////////////////////////////////////////////////////////////////////////////
-            if(process.getMinInputRecords() != null)
-            {
-               if(queryOutput.getRecords().size() < process.getMinInputRecords())
-               {
-                  throw (new QUserFacingException("Too few records were selected for this process.  At least " + process.getMinInputRecords() + " must be selected."));
-               }
-            }
+            // todo - handle 0 results found?
          }
       }
    }

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

@@ -82,7 +82,7 @@ public class RunProcessAction
    public static final String BASEPULL_THIS_RUNTIME_KEY = "basepullThisRuntimeKey";
    public static final String BASEPULL_LAST_RUNTIME_KEY = "basepullLastRuntimeKey";
    public static final String BASEPULL_TIMESTAMP_FIELD  = "basepullTimestampField";
-   public static final String BASEPULL_CONFIGURATION    = "basepullConfiguration";
+   public static final String BASEPULL_CONFIGURATION = "basepullConfiguration";
 
    ////////////////////////////////////////////////////////////////////////////////////////////////
    // indicator that the timestamp field should be updated - e.g., the execute step is finished. //
@@ -190,25 +190,7 @@ public class RunProcessAction
                // Run backend steps //
                ///////////////////////
                LOG.debug("Running backend step [" + step.getName() + "] in process [" + process.getName() + "]");
-               RunBackendStepOutput runBackendStepOutput = runBackendStep(runProcessInput, process, runProcessOutput, stateKey, backendStepMetaData, process, processState);
-
-               /////////////////////////////////////////////////////////////////////////////////////////
-               // if the step returned an override lastStepName, use that to determine how we proceed //
-               /////////////////////////////////////////////////////////////////////////////////////////
-               if(runBackendStepOutput.getOverrideLastStepName() != null)
-               {
-                  LOG.debug("Process step [" + lastStepName + "] returned an overrideLastStepName [" + runBackendStepOutput.getOverrideLastStepName() + "]!");
-                  lastStepName = runBackendStepOutput.getOverrideLastStepName();
-               }
-
-               /////////////////////////////////////////////////////////////////////////////////////////////
-               // similarly, if the step produced an updatedFrontendStepList, propagate that data outward //
-               /////////////////////////////////////////////////////////////////////////////////////////////
-               if(runBackendStepOutput.getUpdatedFrontendStepList() != null)
-               {
-                  LOG.debug("Process step [" + lastStepName + "] generated an updatedFrontendStepList [" + runBackendStepOutput.getUpdatedFrontendStepList().stream().map(s -> s.getName()).toList() + "]!");
-                  runProcessOutput.setUpdatedFrontendStepList(runBackendStepOutput.getUpdatedFrontendStepList());
-               }
+               runBackendStep(runProcessInput, process, runProcessOutput, stateKey, backendStepMetaData, process, processState);
             }
             else
             {
@@ -335,13 +317,6 @@ public class RunProcessAction
          ///////////////////////////////////////////////////
          runProcessInput.seedFromProcessState(optionalProcessState.get());
 
-         ///////////////////////////////////////////////////////////////////////////////////////////////////
-         // if we're restoring an old state, we can discard a previously stored updatedFrontendStepList - //
-         // it is only needed on the transitional edge from a backend-step to a frontend step, but not    //
-         // in the other directly                                                                         //
-         ///////////////////////////////////////////////////////////////////////////////////////////////////
-         optionalProcessState.get().setUpdatedFrontendStepList(null);
-
          ///////////////////////////////////////////////////////////////////////////
          // if there were values from the caller, put those (back) in the request //
          ///////////////////////////////////////////////////////////////////////////
@@ -364,7 +339,7 @@ public class RunProcessAction
    /*******************************************************************************
     ** Run a single backend step.
     *******************************************************************************/
-   protected RunBackendStepOutput runBackendStep(RunProcessInput runProcessInput, QProcessMetaData process, RunProcessOutput runProcessOutput, UUIDAndTypeStateKey stateKey, QBackendStepMetaData backendStep, QProcessMetaData qProcessMetaData, ProcessState processState) throws Exception
+   private void runBackendStep(RunProcessInput runProcessInput, QProcessMetaData process, RunProcessOutput runProcessOutput, UUIDAndTypeStateKey stateKey, QBackendStepMetaData backendStep, QProcessMetaData qProcessMetaData, ProcessState processState) throws Exception
    {
       RunBackendStepInput runBackendStepInput = new RunBackendStepInput(processState);
       runBackendStepInput.setProcessName(process.getName());
@@ -393,16 +368,14 @@ public class RunProcessAction
          runBackendStepInput.setBasepullLastRunTime((Instant) runProcessInput.getValues().get(BASEPULL_LAST_RUNTIME_KEY));
       }
 
-      RunBackendStepOutput runBackendStepOutput = new RunBackendStepAction().execute(runBackendStepInput);
-      storeState(stateKey, runBackendStepOutput.getProcessState());
+      RunBackendStepOutput lastFunctionResult = new RunBackendStepAction().execute(runBackendStepInput);
+      storeState(stateKey, lastFunctionResult.getProcessState());
 
-      if(runBackendStepOutput.getException() != null)
+      if(lastFunctionResult.getException() != null)
       {
-         runProcessOutput.setException(runBackendStepOutput.getException());
-         throw (runBackendStepOutput.getException());
+         runProcessOutput.setException(lastFunctionResult.getException());
+         throw (lastFunctionResult.getException());
       }
-
-      return (runBackendStepOutput);
    }
 
 
@@ -522,15 +495,15 @@ public class RunProcessAction
       String basepullKeyValue = (basepullConfiguration.getKeyValue() != null) ? basepullConfiguration.getKeyValue() : process.getName();
 
       //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-      // if process specifies that it uses variants, look for that data in the session and append to our basepull key //
+      // if backend specifies that it uses variants, look for that data in the session and append to our basepull key //
       //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-      if(process.getVariantBackend() != null)
+      if(process.getSchedule() != null && process.getVariantBackend() != null)
       {
          QSession         session         = QContext.getQSession();
          QBackendMetaData backendMetaData = QContext.getQInstance().getBackend(process.getVariantBackend());
          if(session.getBackendVariants() == null || !session.getBackendVariants().containsKey(backendMetaData.getVariantOptionsTableTypeValue()))
          {
-            LOG.warn("Could not find Backend Variant information for Backend '" + backendMetaData.getName() + "'");
+            LOG.info("Could not find Backend Variant information for Backend '" + backendMetaData.getName() + "'");
          }
          else
          {

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

@@ -1,146 +0,0 @@
-/*
- * 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.reporting;
-
-
-import java.io.Serializable;
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-import com.kingsrook.qqq.backend.core.exceptions.QException;
-import com.kingsrook.qqq.backend.core.model.data.QRecord;
-import com.kingsrook.qqq.backend.core.model.metadata.tables.UniqueKey;
-
-
-/*******************************************************************************
- ** Subclass of record pipe that ony allows through distinct records, based on
- ** the set of fields specified in the constructor as a uniqueKey.
- *******************************************************************************/
-public class DistinctFilteringRecordPipe extends RecordPipe
-{
-   private UniqueKey         uniqueKey;
-   private Set<Serializable> seenValues = new HashSet<>();
-
-
-
-   /*******************************************************************************
-    ** Constructor
-    **
-    *******************************************************************************/
-   public DistinctFilteringRecordPipe(UniqueKey uniqueKey)
-   {
-      this.uniqueKey = uniqueKey;
-   }
-
-
-
-   /*******************************************************************************
-    ** Constructor that accepts pipe's overrideCapacity (allowed to be null)
-    **
-    *******************************************************************************/
-   public DistinctFilteringRecordPipe(UniqueKey uniqueKey, Integer overrideCapacity)
-   {
-      super(overrideCapacity);
-      this.uniqueKey = uniqueKey;
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   @Override
-   public void addRecords(List<QRecord> records) throws QException
-   {
-      List<QRecord> recordsToAdd = new ArrayList<>();
-      for(QRecord record : records)
-      {
-         if(!seenBefore(record))
-         {
-            recordsToAdd.add(record);
-         }
-      }
-
-      if(recordsToAdd.isEmpty())
-      {
-         return;
-      }
-
-      super.addRecords(recordsToAdd);
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   @Override
-   public void addRecord(QRecord record) throws QException
-   {
-      if(seenBefore(record))
-      {
-         return;
-      }
-
-      super.addRecord(record);
-   }
-
-
-
-   /*******************************************************************************
-    ** return true if we've seen this record before (based on the unique key) -
-    ** also - update the set of seen values!
-    *******************************************************************************/
-   private boolean seenBefore(QRecord record)
-   {
-      Serializable ukValues = extractUKValues(record);
-      if(seenValues.contains(ukValues))
-      {
-         return true;
-      }
-      seenValues.add(ukValues);
-      return false;
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   private Serializable extractUKValues(QRecord record)
-   {
-      if(uniqueKey.getFieldNames().size() == 1)
-      {
-         return (record.getValue(uniqueKey.getFieldNames().get(0)));
-      }
-      else
-      {
-         ArrayList<Serializable> rs = new ArrayList<>();
-         for(String fieldName : uniqueKey.getFieldNames())
-         {
-            rs.add(record.getValue(fieldName));
-         }
-         return (rs);
-      }
-   }
-}

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

@@ -190,9 +190,6 @@ public class ExportAction
       Set<String>     addedJoinNames = new HashSet<>();
       if(CollectionUtils.nullSafeHasContents(exportInput.getFieldNames()))
       {
-         /////////////////////////////////////////////////////////////////////////////////////////////
-         // make sure that any tables being selected from are included as (LEFT) joins in the query //
-         /////////////////////////////////////////////////////////////////////////////////////////////
          for(String fieldName : exportInput.getFieldNames())
          {
             if(fieldName.contains("."))
@@ -201,7 +198,27 @@ public class ExportAction
                String   joinTableName = parts[0];
                if(!addedJoinNames.contains(joinTableName))
                {
-                  queryJoins.add(new QueryJoin(joinTableName).withType(QueryJoin.Type.LEFT).withSelect(true));
+                  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);
                }
             }

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

@@ -136,8 +136,8 @@ public class GenerateReportAction extends AbstractQActionFunction<ReportInput, R
     *******************************************************************************/
    public ReportOutput execute(ReportInput reportInput) throws QException
    {
-      ReportOutput    reportOutput = new ReportOutput();
-      QReportMetaData report       = getReportMetaData(reportInput);
+      ReportOutput reportOutput = new ReportOutput();
+      QReportMetaData report = getReportMetaData(reportInput);
 
       this.views = report.getViews();
       this.dataSources = report.getDataSources();
@@ -398,7 +398,7 @@ public class GenerateReportAction extends AbstractQActionFunction<ReportInput, R
       RunBackendStepInput   finalTransformStepInput  = transformStepInput;
       RunBackendStepOutput  finalTransformStepOutput = transformStepOutput;
 
-      String        tableLabel    = ObjectUtils.tryElse(() -> QContext.getQInstance().getTable(dataSource.getSourceTable()).getLabel(), Objects.requireNonNullElse(dataSource.getSourceTable(), ""));
+      String tableLabel = ObjectUtils.tryElse(() -> QContext.getQInstance().getTable(dataSource.getSourceTable()).getLabel(), Objects.requireNonNullElse(dataSource.getSourceTable(), ""));
       AtomicInteger consumedCount = new AtomicInteger(0);
 
       /////////////////////////////////////////////////////////////////
@@ -457,7 +457,7 @@ public class GenerateReportAction extends AbstractQActionFunction<ReportInput, R
          if(finalTransformStep != null)
          {
             finalTransformStepInput.setRecords(records);
-            finalTransformStep.runOnePage(finalTransformStepInput, finalTransformStepOutput);
+            finalTransformStep.run(finalTransformStepInput, finalTransformStepOutput);
             records = finalTransformStepOutput.getRecords();
          }
 
@@ -557,7 +557,7 @@ public class GenerateReportAction extends AbstractQActionFunction<ReportInput, R
    /*******************************************************************************
     **
     *******************************************************************************/
-   private void setInputValuesInQueryFilter(ReportInput reportInput, QQueryFilter queryFilter) throws QException
+   private void setInputValuesInQueryFilter(ReportInput reportInput, QQueryFilter queryFilter)
    {
       if(queryFilter == null || queryFilter.getCriteria() == null)
       {
@@ -704,24 +704,8 @@ public class GenerateReportAction extends AbstractQActionFunction<ReportInput, R
       //////////////////////////////////////////////////////////////////////////////////////
       for(String fieldName : record.getValues().keySet())
       {
-         QFieldMetaData field = null;
-         try
-         {
-            //////////////////////////////////////////////////////
-            // todo - memoize this, if we ever need to optimize //
-            //////////////////////////////////////////////////////
-            FieldAndJoinTable fieldAndJoinTable = getFieldAndJoinTable(table, fieldName);
-            field = fieldAndJoinTable.field();
-         }
-         catch(Exception e)
-         {
-            //////////////////////////////////////////////////////////////////////////////////////
-            // for non-real-fields... let's skip for now - but maybe treat as string in future? //
-            //////////////////////////////////////////////////////////////////////////////////////
-            LOG.debug("Couldn't find field in table qInstance - won't compute aggregates for it", logPair("fieldName", fieldName));
-            continue;
-         }
-
+         FieldAndJoinTable fieldAndJoinTable = getFieldAndJoinTable(table, fieldName);
+         QFieldMetaData    field             = fieldAndJoinTable.field();
          if(StringUtils.hasContent(field.getPossibleValueSourceName()))
          {
             @SuppressWarnings("unchecked")

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

@@ -24,7 +24,6 @@ package com.kingsrook.qqq.backend.core.actions.reporting;
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Objects;
 import java.util.concurrent.ArrayBlockingQueue;
 import java.util.concurrent.TimeUnit;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
@@ -44,9 +43,8 @@ public class RecordPipe
 
    private static final long BLOCKING_SLEEP_MILLIS = 100;
    private static final long MAX_SLEEP_LOOP_MILLIS = 300_000; // 5 minutes
-   private static final int  DEFAULT_CAPACITY      = 1_000;
 
-   private int capacity = DEFAULT_CAPACITY;
+   private int capacity = 1_000;
    private ArrayBlockingQueue<QRecord> queue = new ArrayBlockingQueue<>(capacity);
 
    private boolean isTerminated = false;
@@ -72,13 +70,11 @@ public class RecordPipe
 
    /*******************************************************************************
     ** Construct a record pipe, with an alternative capacity for the internal queue.
-    **
-    ** overrideCapacity is allowed to be null - in which case, DEFAULT_CAPACITY is used.
     *******************************************************************************/
    public RecordPipe(Integer overrideCapacity)
    {
-      this.capacity = Objects.requireNonNullElse(overrideCapacity, DEFAULT_CAPACITY);
-      queue = new ArrayBlockingQueue<>(this.capacity);
+      this.capacity = overrideCapacity;
+      queue = new ArrayBlockingQueue<>(overrideCapacity);
    }
 
 

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/reporting/excel/poi/ExcelPoiBasedStreamingExportStreamer.java

@@ -211,7 +211,6 @@ public class ExcelPoiBasedStreamingExportStreamer implements ExportStreamerInter
 
          /////////////////////////////////////////////////////////////////////////////////////////////
          // open up a zipOutputStream around the output stream that the report is to be written to. //
-         // note:  this stream is closed in the finish method - see more comments there.            //
          /////////////////////////////////////////////////////////////////////////////////////////////
          this.zipOutputStream = new ZipOutputStream(this.outputStream);
 
@@ -330,6 +329,10 @@ public class ExcelPoiBasedStreamingExportStreamer implements ExportStreamerInter
       {
          int columnLabelColumnIndex = getColumnIndex(dataView.getColumns(), value.getFieldName());
 
+         /////////////////////////////////////////////////////////////////////////////////////////////////////////
+         // todo - some bug where, if use a group-by field here, then ... it doesn't get used for the grouping. //
+         //  g-sheets does let me do this, so, maybe, download their file and see how it's different?           //
+         /////////////////////////////////////////////////////////////////////////////////////////////////////////
          String labelPrefix = value.getFunction().name() + " of ";
          String label       = labelPrefix + QInstanceEnricher.nameToLabel(value.getFieldName());
          String valueFormat = null;

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

@@ -77,6 +77,7 @@ public class ExecuteCodeAction
    /*******************************************************************************
     **
     *******************************************************************************/
+   @SuppressWarnings("checkstyle:indentation")
    public void run(ExecuteCodeInput input, ExecuteCodeOutput output) throws QException, QCodeException
    {
       QCodeReference codeReference = input.getCodeReference();

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

@@ -470,7 +470,7 @@ public class DeleteAction
                QRecord recordWithError = new QRecord();
                recordsWithErrors.add(recordWithError);
                recordWithError.setValue(primaryKeyField.getName(), primaryKeyValue);
-               recordWithError.addError(new NotFoundStatusMessage("No record was found to delete for " + Objects.requireNonNullElse(primaryKeyField.getLabel(), primaryKeyField.getName()) + " = " + primaryKeyValue));
+               recordWithError.addError(new NotFoundStatusMessage("No record was found to delete for " + primaryKeyField.getLabel() + " = " + primaryKeyValue));
             }
          }
       }

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

@@ -65,6 +65,16 @@ public class GetAction
 
 
 
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public QRecord executeForRecord(GetInput getInput) throws QException
+   {
+      return (execute(getInput).getRecord());
+   }
+
+
+
    /*******************************************************************************
     **
     *******************************************************************************/
@@ -98,7 +108,7 @@ public class GetAction
       }
 
       GetOutput getOutput;
-      boolean   usingDefaultGetInterface = false;
+      boolean usingDefaultGetInterface = false;
       if(getInterface == null)
       {
          getInterface = new DefaultGetInterface();
@@ -130,43 +140,6 @@ public class GetAction
 
 
 
-   /*******************************************************************************
-    ** shorthand way to call for the most common use-case, when you just want the
-    ** output record to be returned.
-    *******************************************************************************/
-   public QRecord executeForRecord(GetInput getInput) throws QException
-   {
-      return (execute(getInput).getRecord());
-   }
-
-
-
-   /*******************************************************************************
-    ** more shorthand way to call for the most common use-case, when you just want the
-    ** output record to be returned, and you just want to pass in a table name and primary key.
-    *******************************************************************************/
-   public static QRecord execute(String tableName, Serializable primaryKey) throws QException
-   {
-      GetAction getAction = new GetAction();
-      GetInput  getInput  = new GetInput(tableName).withPrimaryKey(primaryKey);
-      return getAction.executeForRecord(getInput);
-   }
-
-
-
-   /*******************************************************************************
-    ** more shorthand way to call for the most common use-case, when you just want the
-    ** output record to be returned, and you just want to pass in a table name and unique key
-    *******************************************************************************/
-   public static QRecord execute(String tableName, Map<String, Serializable> uniqueKey) throws QException
-   {
-      GetAction getAction = new GetAction();
-      GetInput  getInput  = new GetInput(tableName).withUniqueKey(uniqueKey);
-      return getAction.executeForRecord(getInput);
-   }
-
-
-
    /*******************************************************************************
     ** 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).

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

@@ -62,7 +62,6 @@ 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.DuplicateKeyBadInputStatusMessage;
 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;
@@ -415,7 +414,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(new DuplicateKeyBadInputStatusMessage("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

@@ -151,22 +151,6 @@ public class QueryAction
 
 
 
-   /*******************************************************************************
-    ** shorthand way to call for the most common use-case, when you just want the
-    ** records to be returned, and you just want to pass in a table name and filter.
-    *******************************************************************************/
-   public static List<QRecord> execute(String tableName, QQueryFilter filter) throws QException
-   {
-      QueryAction queryAction = new QueryAction();
-      QueryInput  queryInput  = new QueryInput();
-      queryInput.setTableName(tableName);
-      queryInput.setFilter(filter);
-      QueryOutput queryOutput = queryAction.execute(queryInput);
-      return (queryOutput.getRecords());
-   }
-
-
-
    /*******************************************************************************
     **
     *******************************************************************************/
@@ -185,7 +169,6 @@ public class QueryAction
             nextLevelQueryInput.setTableName(association.getAssociatedTableName());
             nextLevelQueryInput.setIncludeAssociations(true);
             nextLevelQueryInput.setAssociationNamesToInclude(buildNextLevelAssociationNamesToInclude(association.getName(), queryInput.getAssociationNamesToInclude()));
-            nextLevelQueryInput.setTransaction(queryInput.getTransaction());
 
             QQueryFilter filter = new QQueryFilter();
             nextLevelQueryInput.setFilter(filter);

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

@@ -157,17 +157,6 @@ public class ReplaceAction extends AbstractQActionFunction<ReplaceInput, Replace
             output.setDeleteOutput(deleteOutput);
          }
 
-         if(input.getSetPrimaryKeyInInsertedRecords())
-         {
-            for(int i = 0; i < insertList.size(); i++)
-            {
-               if(i < insertOutput.getRecords().size())
-               {
-                  insertList.get(i).setValue(primaryKeyField, insertOutput.getRecords().get(i).getValue(primaryKeyField));
-               }
-            }
-         }
-
          if(weOwnTheTransaction)
          {
             transaction.commit();

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

@@ -93,28 +93,4 @@ public class StorageAction
       QBackendModuleInterface  qModule                  = qBackendModuleDispatcher.getQBackendModule(backend);
       return (qModule);
    }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   public void makePublic(StorageInput storageInput) throws QException
-   {
-      QBackendModuleInterface qBackendModuleInterface = preAction(storageInput);
-      QStorageInterface       storageInterface        = qBackendModuleInterface.getStorageInterface();
-      storageInterface.makePublic(storageInput);
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   public String getDownloadURL(StorageInput storageInput) throws QException
-   {
-      QBackendModuleInterface qBackendModuleInterface = preAction(storageInput);
-      QStorageInterface       storageInterface        = qBackendModuleInterface.getStorageInterface();
-      return (storageInterface.getDownloadURL(storageInput));
-   }
 }

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

@@ -24,7 +24,6 @@ package com.kingsrook.qqq.backend.core.actions.tables;
 
 import java.io.Serializable;
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -69,7 +68,6 @@ 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.QErrorMessage;
 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;
@@ -336,9 +334,6 @@ public class UpdateAction
       QTableMetaData table           = updateInput.getTable();
       QFieldMetaData primaryKeyField = table.getField(table.getPrimaryKeyField());
 
-      /////////////////////////////////////////////////////////////
-      // todo - evolve to use lock tree (e.g., from multi-locks) //
-      /////////////////////////////////////////////////////////////
       List<RecordSecurityLock> onlyWriteLocks = RecordSecurityLockFilters.filterForOnlyWriteLocks(CollectionUtils.nonNullList(table.getRecordSecurityLocks()));
 
       for(List<QRecord> page : CollectionUtils.getPages(updateInput.getRecords(), 1000))
@@ -398,12 +393,7 @@ public class UpdateAction
                   QRecord      oldRecord = lookedUpRecords.get(value);
                   QFieldType   fieldType = table.getField(lock.getFieldName()).getType();
                   Serializable lockValue = ValueUtils.getValueAsFieldType(fieldType, oldRecord.getValue(lock.getFieldName()));
-
-                  List<QErrorMessage> errors = ValidateRecordSecurityLockHelper.validateRecordSecurityValue(table, lock, lockValue, fieldType, ValidateRecordSecurityLockHelper.Action.UPDATE, Collections.emptyMap());
-                  if(CollectionUtils.nullSafeHasContents(errors))
-                  {
-                     errors.forEach(e -> record.addError(e));
-                  }
+                  ValidateRecordSecurityLockHelper.validateRecordSecurityValue(table, record, lock, lockValue, fieldType, ValidateRecordSecurityLockHelper.Action.UPDATE);
                }
             }
          }

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

@@ -214,78 +214,71 @@ public class QueryStatManager
     *******************************************************************************/
    public void add(QueryStat queryStat)
    {
-      try
+      if(queryStat == null)
       {
-         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(active)
+         if(queryStat.getSessionId() == null && QContext.getQSession() != null)
          {
-            ////////////////////////////////////////////////////////////////////////////////////////
-            // set fields that we need to capture now (rather than when the thread to store runs) //
-            ////////////////////////////////////////////////////////////////////////////////////////
-            if(queryStat.getFirstResultTimestamp() == null)
-            {
-               queryStat.setFirstResultTimestamp(Instant.now());
-            }
+            queryStat.setSessionId(QContext.getQSession().getUuid());
+         }
 
-            if(queryStat.getStartTimestamp() != null && queryStat.getFirstResultTimestamp() != null && queryStat.getFirstResultMillis() == null)
+         if(queryStat.getAction() == null)
+         {
+            if(!QContext.getActionStack().isEmpty())
             {
-               long millis = queryStat.getFirstResultTimestamp().toEpochMilli() - queryStat.getStartTimestamp().toEpochMilli();
-               queryStat.setFirstResultMillis((int) millis);
+               queryStat.setAction(QContext.getActionStack().peek().getActionIdentity());
             }
-
-            if(queryStat.getFirstResultMillis() != null && queryStat.getFirstResultMillis() < minMillisToStore)
+            else
             {
-               //////////////////////////////////////////////////////////////
-               // 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() != null && !QContext.getActionStack().isEmpty())
+               boolean   expected = false;
+               Exception e        = new Exception("Unexpected empty action stack");
+               for(StackTraceElement stackTraceElement : e.getStackTrace())
                {
-                  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()))
                   {
-                     String className = stackTraceElement.getClassName();
-                     if(className.contains(QueryStatManagerInsertJob.class.getName()))
-                     {
-                        expected = true;
-                        break;
-                     }
-                  }
-
-                  if(!expected)
-                  {
-                     LOG.debug(e);
+                     expected = true;
+                     break;
                   }
                }
-            }
 
-            synchronized(this)
-            {
-               queryStats.add(queryStat);
+               if(!expected)
+               {
+                  LOG.debug(e);
+               }
             }
          }
-      }
-      catch(Exception e)
-      {
-         LOG.debug("Error adding query stat", e);
+
+         synchronized(this)
+         {
+            queryStats.add(queryStat);
+         }
       }
    }
 

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

@@ -24,7 +24,6 @@ package com.kingsrook.qqq.backend.core.actions.tables.helpers;
 
 import java.io.Serializable;
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -43,16 +42,13 @@ 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.MultiRecordSecurityLock;
 import com.kingsrook.qqq.backend.core.model.metadata.security.NullValueBehaviorUtil;
 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.model.statusmessages.QErrorMessage;
 import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
-import com.kingsrook.qqq.backend.core.utils.JsonUtils;
 import com.kingsrook.qqq.backend.core.utils.ListingHash;
 import com.kingsrook.qqq.backend.core.utils.StringUtils;
 import com.kingsrook.qqq.backend.core.utils.ValueUtils;
@@ -85,273 +81,160 @@ public class ValidateRecordSecurityLockHelper
     *******************************************************************************/
    public static void validateSecurityFields(QTableMetaData table, List<QRecord> records, Action action) throws QException
    {
-      MultiRecordSecurityLock locksToCheck = getRecordSecurityLocks(table, action);
-      if(locksToCheck == null || CollectionUtils.nullSafeIsEmpty(locksToCheck.getLocks()))
+      List<RecordSecurityLock> locksToCheck = getRecordSecurityLocks(table, action);
+      if(CollectionUtils.nullSafeIsEmpty(locksToCheck))
       {
          return;
       }
 
-      //////////////////////////////////////////////////////////////////////////////////////////
-      // we will be relying on primary keys being set in records - but (at least for inserts) //
-      // we might not have pkeys - so make them up (and clear them out at the end)            //
-      //////////////////////////////////////////////////////////////////////////////////////////
-      Map<Serializable, QRecord> madeUpPrimaryKeys = makeUpPrimaryKeysIfNeeded(records, table);
-
       ////////////////////////////////
       // actually check lock values //
       ////////////////////////////////
-      Map<Serializable, RecordWithErrors> errorRecords = new HashMap<>();
-      evaluateRecordLocks(table, records, action, locksToCheck, errorRecords, new ArrayList<>(), madeUpPrimaryKeys);
-
-      /////////////////////////////////
-      // propagate errors to records //
-      /////////////////////////////////
-      for(RecordWithErrors recordWithErrors : errorRecords.values())
+      for(RecordSecurityLock recordSecurityLock : locksToCheck)
       {
-         recordWithErrors.propagateErrorsToRecord(locksToCheck);
-      }
-
-      /////////////////////////////////
-      // remove made-up primary keys //
-      /////////////////////////////////
-      String primaryKeyField = table.getPrimaryKeyField();
-      for(QRecord record : madeUpPrimaryKeys.values())
-      {
-         record.setValue(primaryKeyField, null);
-      }
-   }
-
-
-
-   /*******************************************************************************
-    ** For a list of `records` from a `table`, and a given `action`, evaluate a
-    ** `recordSecurityLock` (which may be a multi-lock) - populating the input map
-    ** of `errorRecords` - key'ed by primary key value (real or made up), with
-    ** error messages existing in a tree, with positions matching the multi-lock
-    ** tree that we're navigating, as tracked by `treePosition`.
-    **
-    ** Recursively processes multi-locks (and the top-level call is always with a
-    ** multi-lock - as the table's recordLocks list converted to an AND-multi-lock).
-    **
-    ** Of note - for the case of READ_WRITE locks, we're only evaluating the values
-    ** on the record, to see if they're allowed for us to store (because if we didn't
-    ** have the key, we wouldn't have been able to read the value (which is verified
-    ** outside of here, in UpdateAction/DeleteAction).
-    **
-    ** BUT - WRITE locks - in their case, we read the record no matter what, and in
-    ** here we need to verify we have a key that allows us to WRITE the record.
-    *******************************************************************************/
-   private static void evaluateRecordLocks(QTableMetaData table, List<QRecord> records, Action action, RecordSecurityLock recordSecurityLock, Map<Serializable, RecordWithErrors> errorRecords, List<Integer> treePosition, Map<Serializable, QRecord> madeUpPrimaryKeys) throws QException
-   {
-      if(recordSecurityLock instanceof MultiRecordSecurityLock multiRecordSecurityLock)
-      {
-         /////////////////////////////////////////////
-         // for multi-locks, make recursive descent //
-         /////////////////////////////////////////////
-         int i = 0;
-         for(RecordSecurityLock childLock : CollectionUtils.nonNullList(multiRecordSecurityLock.getLocks()))
+         if(CollectionUtils.nullSafeIsEmpty(recordSecurityLock.getJoinNameChain()))
          {
-            treePosition.add(i);
-            evaluateRecordLocks(table, records, action, childLock, errorRecords, treePosition, madeUpPrimaryKeys);
-            treePosition.remove(treePosition.size() - 1);
-            i++;
-         }
+            //////////////////////////////////////////////////////////////////////////////////
+            // handle the value being in the table we're inserting/updating (e.g., no join) //
+            //////////////////////////////////////////////////////////////////////////////////
+            QFieldMetaData field = table.getField(recordSecurityLock.getFieldName());
 
-         return;
-      }
-
-      /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-      // if this lock has an all-access key, and the user has that key, then there can't be any errors here, so return early //
-      /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-      QSecurityKeyType securityKeyType = QContext.getQInstance().getSecurityKeyType(recordSecurityLock.getSecurityKeyType());
-      if(StringUtils.hasContent(securityKeyType.getAllAccessKeyName()) && QContext.getQSession().hasSecurityKeyValue(securityKeyType.getAllAccessKeyName(), true, QFieldType.BOOLEAN))
-      {
-         return;
-      }
-
-      ////////////////////////////////
-      // proceed w/ non-multi locks //
-      ////////////////////////////////
-      String primaryKeyField = table.getPrimaryKeyField();
-      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()))
+            for(QRecord record : records)
             {
-               /////////////////////////////////////////////////////////////////////////////////////////////////////////
-               // 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;
-            }
+               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());
-            List<QErrorMessage> recordErrors        = validateRecordSecurityValue(table, recordSecurityLock, recordSecurityValue, field.getType(), action, madeUpPrimaryKeys);
-            if(CollectionUtils.nullSafeHasContents(recordErrors))
-            {
-               errorRecords.computeIfAbsent(record.getValue(primaryKeyField), (k) -> new RecordWithErrors(record)).addAll(recordErrors, treePosition);
+               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));
-
-         ////////////////////////////////
-         // todo probably, but more... //
-         ////////////////////////////////
-         // if(leftMostJoin.getLeftTable().equals(table.getName()))
-         // {
-         //    leftMostJoin = leftMostJoin.flip();
-         // }
-
-         QTableMetaData rightMostJoinTable = QContext.getQInstance().getTable(rightMostJoin.getRightTable());
-         QTableMetaData leftMostJoinTable  = QContext.getQInstance().getTable(leftMostJoin.getLeftTable());
-
-         for(List<QRecord> inputRecordPage : CollectionUtils.getPages(records, 500))
+         else
          {
-            ////////////////////////////////////////////////////////////////////////////////////////////////
-            // 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);
+            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+            // 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(String joinName : recordSecurityLock.getJoinNameChain())
+            for(List<QRecord> inputRecordPage : CollectionUtils.getPages(records, 500))
             {
-               ///////////////////////////////////////
-               // we don't need the right-most join //
-               ///////////////////////////////////////
-               if(!joinName.equals(rightMostJoin.getName()))
+               ////////////////////////////////////////////////////////////////////////////////////////////////
+               // 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())
                {
-                  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();
-
-               boolean updatingAnyLockJoinFields = false;
-               for(JoinOn joinOn : rightMostJoin.getJoinOns())
-               {
-                  QFieldType   type             = rightMostJoinTable.getField(joinOn.getRightField()).getType();
-                  Serializable inputRecordValue = ValueUtils.getValueAsFieldType(type, inputRecord.getValue(joinOn.getRightField()));
-                  inputRecordJoinValues.add(inputRecordValue);
-
-                  // if we have a value in this field (and it's not the primary key), then it means we're updating part of the lock
-                  if(inputRecordValue != null && !joinOn.getRightField().equals(table.getPrimaryKeyField()))
+                  ///////////////////////////////////////
+                  // we don't need the right-most join //
+                  ///////////////////////////////////////
+                  if(!joinName.equals(rightMostJoin.getName()))
                   {
-                     updatingAnyLockJoinFields = true;
+                     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));
                   }
 
-                  subFilter.addCriteria(inputRecordValue == null
-                     ? new QFilterCriteria(rightMostJoin.getLeftTable() + "." + joinOn.getLeftField(), QCriteriaOperator.IS_BLANK)
-                     : new QFilterCriteria(rightMostJoin.getLeftTable() + "." + joinOn.getLeftField(), QCriteriaOperator.EQUALS, inputRecordValue));
-               }
-
-               //////////////////////////////////
-               // todo maybe, some version of? //
-               //////////////////////////////////
-               // if(action.equals(Action.UPDATE) && !updatingAnyLockJoinFields && 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;
-               // }
-
-               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(".")))
+                  if(!inputRecordMapByJoinFields.containsKey(inputRecordJoinValues))
                   {
-                     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());
+                     ////////////////////////////////////////////////////////////////////////////////
+                     // only add this sub-filter if it's for a list of keys we haven't seen before //
+                     ////////////////////////////////////////////////////////////////////////////////
+                     filter.addSubFilter(subFilter);
                   }
 
-                  for(QRecord inputRecord : inputRecords)
+                  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())
                   {
-                     List<QErrorMessage> recordErrors = validateRecordSecurityValue(table, recordSecurityLock, recordSecurityValue, field.getType(), action, madeUpPrimaryKeys);
-                     if(CollectionUtils.nullSafeHasContents(recordErrors))
+                     Serializable joinValue = joinRecord.getValue(rightMostJoin.getLeftTable() + "." + joinOn.getLeftField());
+                     if(joinValue == null && joinRecord.getValues().keySet().stream().anyMatch(n -> !n.contains(".")))
                      {
-                        errorRecords.computeIfAbsent(inputRecord.getValue(primaryKeyField), (k) -> new RecordWithErrors(inputRecord)).addAll(recordErrors, treePosition);
+                        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)
+                  else
                   {
-                     if(RecordSecurityLock.NullValueBehavior.DENY.equals(NullValueBehaviorUtil.getEffectiveNullValueBehavior(recordSecurityLock)))
+                     for(QRecord inputRecord : inputRecords)
                      {
-                        PermissionDeniedMessage error = new PermissionDeniedMessage("You do not have permission to " + action.name().toLowerCase() + " this record - the referenced " + leftMostJoinTable.getLabel() + " was not found.");
-                        errorRecords.computeIfAbsent(inputRecord.getValue(primaryKeyField), (k) -> new RecordWithErrors(inputRecord)).add(error, treePosition);
+                        if(RecordSecurityLock.NullValueBehavior.DENY.equals(NullValueBehaviorUtil.getEffectiveNullValueBehavior(recordSecurityLock)))
+                        {
+                           inputRecord.addError(new PermissionDeniedMessage("You do not have permission to " + action.name().toLowerCase() + " this record - the referenced " + leftMostJoinTable.getLabel() + " was not found."));
+                        }
                      }
                   }
                }
@@ -363,80 +246,45 @@ public class ValidateRecordSecurityLockHelper
 
 
    /*******************************************************************************
-    ** for tracking errors, we use primary keys.  add "made up" ones to records
-    ** if needed (e.g., insert use-case).
+    **
     *******************************************************************************/
-   private static Map<Serializable, QRecord> makeUpPrimaryKeysIfNeeded(List<QRecord> records, QTableMetaData table)
+   private static List<RecordSecurityLock> getRecordSecurityLocks(QTableMetaData table, Action action)
    {
-      String                     primaryKeyField   = table.getPrimaryKeyField();
-      Map<Serializable, QRecord> madeUpPrimaryKeys = new HashMap<>();
-      Integer                    madeUpPrimaryKey  = Integer.MIN_VALUE / 2;
-      for(QRecord record : records)
+      List<RecordSecurityLock> recordSecurityLocks = CollectionUtils.nonNullList(table.getRecordSecurityLocks());
+      List<RecordSecurityLock> locksToCheck        = new ArrayList<>();
+
+      recordSecurityLocks = switch(action)
       {
-         if(record.getValue(primaryKeyField) == null)
-         {
-            madeUpPrimaryKeys.put(madeUpPrimaryKey, record);
-            record.setValue(primaryKeyField, madeUpPrimaryKey);
-            madeUpPrimaryKey++;
-         }
-      }
-      return madeUpPrimaryKeys;
-   }
-
-
-
-   /*******************************************************************************
-    ** For a given table & action type, convert the table's record locks to a
-    ** MultiRecordSecurityLock, with only the appropriate lock-scopes being included
-    ** (e.g., read-locks for selects, write-locks for insert/update/delete).
-    *******************************************************************************/
-   static MultiRecordSecurityLock getRecordSecurityLocks(QTableMetaData table, Action action)
-   {
-      List<RecordSecurityLock> allLocksOnTable = CollectionUtils.nonNullList(table.getRecordSecurityLocks());
-      MultiRecordSecurityLock locksOfType = switch(action)
-      {
-         case INSERT, UPDATE, DELETE -> RecordSecurityLockFilters.filterForWriteLockTree(allLocksOnTable);
-         case SELECT -> RecordSecurityLockFilters.filterForReadLockTree(allLocksOnTable);
+         case INSERT, UPDATE, DELETE -> RecordSecurityLockFilters.filterForWriteLocks(recordSecurityLocks);
+         case SELECT -> RecordSecurityLockFilters.filterForReadLocks(recordSecurityLocks);
          default -> throw (new IllegalArgumentException("Unsupported action: " + action));
       };
 
-      if(action.equals(Action.UPDATE))
-      {
-         ////////////////////////////////////////////////////////////////////////////
-         // todo at some point this seemed right, but now it doesn't - needs work. //
-         ////////////////////////////////////////////////////////////////////////////
-         // ////////////////////////////////////////////////////////
-         // // when doing an update, convert all OR's to AND's... //
-         // ////////////////////////////////////////////////////////
-         // updateOperators(locksOfType, MultiRecordSecurityLock.BooleanOperator.AND);
-      }
-
       ////////////////////////////////////////
       // if there are no locks, just return //
       ////////////////////////////////////////
-      if(locksOfType == null || CollectionUtils.nullSafeIsEmpty(locksOfType.getLocks()))
+      if(CollectionUtils.nullSafeIsEmpty(recordSecurityLocks))
       {
          return (null);
       }
 
-      return (locksOfType);
-   }
-
-
-
-   /*******************************************************************************
-    ** for a full multi-lock tree, set all of the boolean operators to the specified one.
-    *******************************************************************************/
-   private static void updateOperators(MultiRecordSecurityLock multiLock, MultiRecordSecurityLock.BooleanOperator operator)
-   {
-      multiLock.setOperator(operator);
-      for(RecordSecurityLock childLock : multiLock.getLocks())
+      ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // 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)
       {
-         if(childLock instanceof MultiRecordSecurityLock childMultiLock)
+         QSecurityKeyType securityKeyType = QContext.getQInstance().getSecurityKeyType(recordSecurityLock.getSecurityKeyType());
+         if(StringUtils.hasContent(securityKeyType.getAllAccessKeyName()) && QContext.getQSession().hasSecurityKeyValue(securityKeyType.getAllAccessKeyName(), true, QFieldType.BOOLEAN))
          {
-            updateOperators(childMultiLock, operator);
+            LOG.trace("Session has " + securityKeyType.getAllAccessKeyName() + " - not checking this lock.");
+         }
+         else
+         {
+            locksToCheck.add(recordSecurityLock);
          }
       }
+
+      return (locksToCheck);
    }
 
 
@@ -444,9 +292,9 @@ public class ValidateRecordSecurityLockHelper
    /*******************************************************************************
     **
     *******************************************************************************/
-   public static List<QErrorMessage> validateRecordSecurityValue(QTableMetaData table, RecordSecurityLock recordSecurityLock, Serializable recordSecurityValue, QFieldType fieldType, Action action, Map<Serializable, QRecord> madeUpPrimaryKeys)
+   public static void validateRecordSecurityValue(QTableMetaData table, QRecord record, RecordSecurityLock recordSecurityLock, Serializable recordSecurityValue, QFieldType fieldType, Action action)
    {
-      if(recordSecurityValue == null || (madeUpPrimaryKeys != null && madeUpPrimaryKeys.containsKey(recordSecurityValue)))
+      if(recordSecurityValue == null)
       {
          /////////////////////////////////////////////////////////////////
          // handle null values - error if the NullValueBehavior is DENY //
@@ -454,7 +302,7 @@ public class ValidateRecordSecurityLockHelper
          if(RecordSecurityLock.NullValueBehavior.DENY.equals(NullValueBehaviorUtil.getEffectiveNullValueBehavior(recordSecurityLock)))
          {
             String lockLabel = CollectionUtils.nullSafeHasContents(recordSecurityLock.getJoinNameChain()) ? recordSecurityLock.getSecurityKeyType() : table.getField(recordSecurityLock.getFieldName()).getLabel();
-            return (List.of(new PermissionDeniedMessage("You do not have permission to " + action.name().toLowerCase() + " a record without a value in the field: " + lockLabel)));
+            record.addError(new PermissionDeniedMessage("You do not have permission to " + action.name().toLowerCase() + " a record without a value in the field: " + lockLabel));
          }
       }
       else
@@ -466,305 +314,15 @@ public class ValidateRecordSecurityLockHelper
                ///////////////////////////////////////////////////////////////////////////////////////////////
                // avoid telling the user a value from a foreign record that they didn't pass in themselves. //
                ///////////////////////////////////////////////////////////////////////////////////////////////
-               return (List.of(new PermissionDeniedMessage("You do not have permission to " + action.name().toLowerCase() + " this record.")));
+               record.addError(new PermissionDeniedMessage("You do not have permission to " + action.name().toLowerCase() + " this record."));
             }
             else
             {
                QFieldMetaData field = table.getField(recordSecurityLock.getFieldName());
-               return (List.of(new PermissionDeniedMessage("You do not have permission to " + action.name().toLowerCase() + " a record with a value of " + recordSecurityValue + " in the field: " + field.getLabel())));
+               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()));
             }
          }
       }
-      return (Collections.emptyList());
-   }
-
-
-
-   /*******************************************************************************
-    ** Class to track errors that we're associating with a record.
-    **
-    ** More complex than it first seems to be needed, because as we're evaluating
-    ** locks, we might find some, but based on the boolean condition associated with
-    ** them, they might not actually be record-level errors.
-    **
-    ** e.g., two locks with an OR relationship - as long as one passes, the record
-    ** should have no errors.  And so-on through the tree of locks/multi-locks.
-    **
-    ** Stores the errors in a tree of ErrorTreeNode objects.
-    **
-    ** References into that tree are achieved via a List of Integer called "tree positions"
-    ** where each entry in the list denotes the index of the tree node at that level.
-    **
-    ** e.g., given this tree:
-    ** <pre>
-    **   A      B
-    **  / \    /|\
-    ** C   D  E F G
-    **     |
-    **     H
-    ** </pre>
-    **
-    ** The positions of each node would be:
-    ** <pre>
-    ** A: [0]
-    ** B: [1]
-    ** C: [0,0]
-    ** D: [0,1]
-    ** E: [1,0]
-    ** F: [1,1]
-    ** G: [1,2]
-    ** H: [0,1,0]
-    ** </pre>
-    *******************************************************************************/
-   static class RecordWithErrors
-   {
-      private QRecord       record;
-      private ErrorTreeNode errorTree;
-
-
-
-      /*******************************************************************************
-       ** Constructor
-       **
-       *******************************************************************************/
-      public RecordWithErrors(QRecord record)
-      {
-         this.record = record;
-      }
-
-
-
-      /*******************************************************************************
-       ** add a list of errors, for a given list of tree positions
-       *******************************************************************************/
-      public void addAll(List<QErrorMessage> recordErrors, List<Integer> treePositions)
-      {
-         if(errorTree == null)
-         {
-            errorTree = new ErrorTreeNode();
-         }
-
-         ErrorTreeNode node = errorTree;
-         for(Integer treePosition : treePositions)
-         {
-            if(node.children == null)
-            {
-               node.children = new ArrayList<>(treePosition);
-            }
-
-            while(treePosition >= node.children.size())
-            {
-               node.children.add(null);
-            }
-
-            if(node.children.get(treePosition) == null)
-            {
-               node.children.set(treePosition, new ErrorTreeNode());
-            }
-
-            node = node.children.get(treePosition);
-         }
-
-         if(node.errors == null)
-         {
-            node.errors = new ArrayList<>();
-         }
-         node.errors.addAll(recordErrors);
-      }
-
-
-
-      /*******************************************************************************
-       ** add a single error to a given tree-position
-       *******************************************************************************/
-      public void add(QErrorMessage error, List<Integer> treePositions)
-      {
-         addAll(List.of(error), treePositions);
-      }
-
-
-
-      /*******************************************************************************
-       ** after the tree of errors has been built - walk a lock-tree (locksToCheck)
-       ** and resolve boolean operations, to get a final list of errors (possibly empty)
-       ** to put on the record.
-       *******************************************************************************/
-      public void propagateErrorsToRecord(MultiRecordSecurityLock locksToCheck)
-      {
-         List<QErrorMessage> errors = recursivePropagation(locksToCheck, new ArrayList<>());
-
-         if(CollectionUtils.nullSafeHasContents(errors))
-         {
-            errors.forEach(e -> record.addError(e));
-         }
-      }
-
-
-
-      /*******************************************************************************
-       ** recursive implementation of the propagation method - e.g., walk tree applying
-       ** boolean logic.
-       *******************************************************************************/
-      private List<QErrorMessage> recursivePropagation(MultiRecordSecurityLock locksToCheck, List<Integer> treePositions)
-      {
-         //////////////////////////////////////////////////////////////////
-         // build a list of errors at this level (and deeper levels too) //
-         //////////////////////////////////////////////////////////////////
-         List<QErrorMessage> errorsFromThisLevel = new ArrayList<>();
-
-         int i = 0;
-         for(RecordSecurityLock lock : locksToCheck.getLocks())
-         {
-            List<QErrorMessage> errorsFromThisLock;
-
-            treePositions.add(i);
-            if(lock instanceof MultiRecordSecurityLock childMultiLock)
-            {
-               errorsFromThisLock = recursivePropagation(childMultiLock, treePositions);
-            }
-            else
-            {
-               errorsFromThisLock = getErrorsFromTree(treePositions);
-            }
-
-            errorsFromThisLevel.addAll(errorsFromThisLock);
-
-            treePositions.remove(treePositions.size() - 1);
-            i++;
-         }
-
-         if(MultiRecordSecurityLock.BooleanOperator.AND.equals(locksToCheck.getOperator()))
-         {
-            //////////////////////////////////////////////////////////////
-            // for an AND - if there were ANY errors, then return them. //
-            //////////////////////////////////////////////////////////////
-            if(!errorsFromThisLevel.isEmpty())
-            {
-               return (errorsFromThisLevel);
-            }
-         }
-         else // OR
-         {
-            //////////////////////////////////////////////////////////
-            // for an OR - only return if ALL conditions had errors //
-            //////////////////////////////////////////////////////////
-            if(errorsFromThisLevel.size() == locksToCheck.getLocks().size())
-            {
-               return (errorsFromThisLevel); // todo something smarter?
-            }
-         }
-
-         ///////////////////////////////////
-         // else - no errors - empty list //
-         ///////////////////////////////////
-         return Collections.emptyList();
-      }
-
-
-
-      /*******************************************************************************
-       **
-       *******************************************************************************/
-      private List<QErrorMessage> getErrorsFromTree(List<Integer> treePositions)
-      {
-         ErrorTreeNode node = errorTree;
-
-         for(Integer treePosition : treePositions)
-         {
-            if(node.children == null)
-            {
-               return Collections.emptyList();
-            }
-
-            if(treePosition >= node.children.size())
-            {
-               return Collections.emptyList();
-            }
-
-            if(node.children.get(treePosition) == null)
-            {
-               return Collections.emptyList();
-            }
-
-            node = node.children.get(treePosition);
-         }
-
-         if(node.errors == null)
-         {
-            return Collections.emptyList();
-         }
-
-         return node.errors;
-      }
-
-
-
-      /*******************************************************************************
-       **
-       *******************************************************************************/
-      @Override
-      public String toString()
-      {
-         try
-         {
-            return JsonUtils.toPrettyJson(this);
-         }
-         catch(Exception e)
-         {
-            return "error in toString";
-         }
-      }
-   }
-
-
-
-   /*******************************************************************************
-    ** tree node used by RecordWithErrors
-    *******************************************************************************/
-   static class ErrorTreeNode
-   {
-      private List<QErrorMessage>      errors;
-      private ArrayList<ErrorTreeNode> children;
-
-
-
-      /*******************************************************************************
-       **
-       *******************************************************************************/
-      @Override
-      public String toString()
-      {
-         try
-         {
-            return JsonUtils.toPrettyJson(this);
-         }
-         catch(Exception e)
-         {
-            return "error in toString";
-         }
-      }
-
-
-
-      /*******************************************************************************
-       ** Getter for errors - only here for Jackson/toString
-       **
-       *******************************************************************************/
-      public List<QErrorMessage> getErrors()
-      {
-         return errors;
-      }
-
-
-
-      /*******************************************************************************
-       ** Getter for children - only here for Jackson/toString
-       **
-       *******************************************************************************/
-      public ArrayList<ErrorTreeNode> getChildren()
-      {
-         return children;
-      }
    }
 
 }

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

@@ -118,7 +118,6 @@ public class QPossibleValueTranslator
    }
 
 
-
    /*******************************************************************************
     ** Constructor
     **
@@ -422,6 +421,7 @@ public class QPossibleValueTranslator
    /*******************************************************************************
     **
     *******************************************************************************/
+   @SuppressWarnings("checkstyle:Indentation")
    private String doFormatPossibleValue(String formatString, List<String> valueFields, Object id, String label)
    {
       List<Object> values = new ArrayList<>();
@@ -560,47 +560,20 @@ public class QPossibleValueTranslator
     *******************************************************************************/
    private void primePvsCache(String tableName, List<QPossibleValueSource> possibleValueSources, Collection<Serializable> values)
    {
-      String idField = null;
       for(QPossibleValueSource possibleValueSource : possibleValueSources)
       {
          possibleValueCache.putIfAbsent(possibleValueSource.getName(), new HashMap<>());
-         String thisPvsIdField;
-         if(StringUtils.hasContent(possibleValueSource.getOverrideIdField()))
-         {
-            thisPvsIdField = possibleValueSource.getOverrideIdField();
-         }
-         else
-         {
-            thisPvsIdField = QContext.getQInstance().getTable(tableName).getPrimaryKeyField();
-         }
-
-         if(idField == null)
-         {
-            idField = thisPvsIdField;
-         }
-         else
-         {
-            /////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            // does this ever happen?  maybe not... because, like, the list of values probably wouldn't make sense for //
-            // more than one field in the table...                                                                     //
-            /////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            if(!idField.equals(thisPvsIdField))
-            {
-               for(QPossibleValueSource valueSource : possibleValueSources)
-               {
-                  primePvsCache(tableName, List.of(valueSource), values);
-               }
-            }
-         }
       }
 
       try
       {
+         String primaryKeyField = QContext.getQInstance().getTable(tableName).getPrimaryKeyField();
+
          for(List<Serializable> page : CollectionUtils.getPages(values, 1000))
          {
             QueryInput queryInput = new QueryInput();
             queryInput.setTableName(tableName);
-            queryInput.setFilter(new QQueryFilter().withCriteria(new QFilterCriteria(idField, QCriteriaOperator.IN, page)));
+            queryInput.setFilter(new QQueryFilter().withCriteria(new QFilterCriteria(primaryKeyField, QCriteriaOperator.IN, page)));
             queryInput.setTransaction(getTransaction(tableName));
 
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -645,7 +618,7 @@ public class QPossibleValueTranslator
             ///////////////////////////////////////////////////////////////////////////////////
             for(QRecord record : queryOutput.getRecords())
             {
-               Serializable pkeyValue = record.getValue(idField);
+               Serializable pkeyValue = record.getValue(primaryKeyField);
                for(QPossibleValueSource possibleValueSource : possibleValueSources)
                {
                   QPossibleValue<?> possibleValue = new QPossibleValue<>(pkeyValue, record.getRecordLabel());

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

@@ -275,19 +275,8 @@ public class SearchPossibleValueSourceAction
 
       queryInput.setFilter(queryFilter);
 
-      QueryOutput queryOutput = new QueryAction().execute(queryInput);
-
-      String fieldName;
-      if(StringUtils.hasContent(possibleValueSource.getOverrideIdField()))
-      {
-         fieldName = possibleValueSource.getOverrideIdField();
-      }
-      else
-      {
-         fieldName = table.getPrimaryKeyField();
-      }
-
-      List<Serializable> ids = queryOutput.getRecords().stream().map(r -> r.getValue(fieldName)).toList();
+      QueryOutput             queryOutput     = new QueryAction().execute(queryInput);
+      List<Serializable>      ids             = queryOutput.getRecords().stream().map(r -> r.getValue(table.getPrimaryKeyField())).toList();
       List<QPossibleValue<?>> qPossibleValues = possibleValueTranslator.buildTranslatedPossibleValueList(possibleValueSource, ids);
       output.setResults(qPossibleValues);
 

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/instances/QInstanceEnricher.java

@@ -384,9 +384,9 @@ public class QInstanceEnricher
          process.setLabel(nameToLabel(process.getName()));
       }
 
-      for(QStepMetaData step : CollectionUtils.nonNullMap(process.getAllSteps()).values())
+      if(process.getStepList() != null)
       {
-         enrichStep(step);
+         process.getStepList().forEach(this::enrichStep);
       }
 
       for(QSupplementalProcessMetaData supplementalProcessMetaData : CollectionUtils.nonNullMap(process.getSupplementalMetaData()).values())

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/instances/QInstanceHelpContentManager.java

@@ -43,7 +43,6 @@ import com.kingsrook.qqq.backend.core.model.metadata.help.HelpFormat;
 import com.kingsrook.qqq.backend.core.model.metadata.help.HelpRole;
 import com.kingsrook.qqq.backend.core.model.metadata.help.QHelpContent;
 import com.kingsrook.qqq.backend.core.model.metadata.help.QHelpRole;
-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.tables.QFieldSection;
 import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
@@ -112,7 +111,6 @@ public class QInstanceHelpContentManager
          String processName = nameValuePairs.get("process");
          String fieldName   = nameValuePairs.get("field");
          String sectionName = nameValuePairs.get("section");
-         String stepName = nameValuePairs.get("step");
          String widgetName  = nameValuePairs.get("widget");
          String slotName    = nameValuePairs.get("slot");
 
@@ -147,7 +145,7 @@ public class QInstanceHelpContentManager
          }
          else if(StringUtils.hasContent(processName))
          {
-            processHelpContentForProcess(key, processName, fieldName, stepName, roles, helpContent);
+            processHelpContentForProcess(key, processName, fieldName, roles, helpContent);
          }
          else if(StringUtils.hasContent(widgetName))
          {
@@ -210,10 +208,6 @@ public class QInstanceHelpContentManager
             optionalSection.get().removeHelpContent(roles);
          }
       }
-      else
-      {
-         LOG.info("Unrecognized key format for table help content", logPair("key", key));
-      }
    }
 
 
@@ -221,7 +215,7 @@ public class QInstanceHelpContentManager
    /*******************************************************************************
     **
     *******************************************************************************/
-   private static void processHelpContentForProcess(String key, String processName, String fieldName, String stepName, Set<HelpRole> roles, QHelpContent helpContent)
+   private static void processHelpContentForProcess(String key, String processName, String fieldName, Set<HelpRole> roles, QHelpContent helpContent)
    {
       QProcessMetaData process = QContext.getQInstance().getProcess(processName);
       if(process == null)
@@ -250,30 +244,6 @@ public class QInstanceHelpContentManager
             optionalField.get().removeHelpContent(roles);
          }
       }
-      else if(StringUtils.hasContent(stepName))
-      {
-         /////////////////////////////
-         // handle a process screen //
-         /////////////////////////////
-         QFrontendStepMetaData frontendStep = process.getFrontendStep(stepName);
-
-         if(frontendStep == null)
-         {
-            LOG.info("Unrecognized process step in help content", logPair("key", key));
-         }
-         else if(helpContent != null)
-         {
-            frontendStep.withHelpContent(helpContent);
-         }
-         else
-         {
-            frontendStep.removeHelpContent(roles);
-         }
-      }
-      else
-      {
-         LOG.info("Unrecognized key format for process help content", logPair("key", key));
-      }
    }
 
 

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/instances/QInstanceValidator.java

@@ -86,7 +86,6 @@ import com.kingsrook.qqq.backend.core.model.metadata.reporting.QReportMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.reporting.QReportView;
 import com.kingsrook.qqq.backend.core.model.metadata.scheduleing.QScheduleMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.security.FieldSecurityLock;
-import com.kingsrook.qqq.backend.core.model.metadata.security.MultiRecordSecurityLock;
 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.tables.AssociatedScript;
@@ -109,7 +108,6 @@ import com.kingsrook.qqq.backend.core.utils.StringUtils;
 import com.kingsrook.qqq.backend.core.utils.ValueUtils;
 import com.kingsrook.qqq.backend.core.utils.lambdas.UnsafeLambda;
 import org.quartz.CronExpression;
-import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
 
 
 /*******************************************************************************
@@ -152,7 +150,6 @@ public class QInstanceValidator
       // once, during the enrichment/validation work, so, capture it, and store it back in the instance. //
       /////////////////////////////////////////////////////////////////////////////////////////////////////
       JoinGraph joinGraph = null;
-      long      start     = System.currentTimeMillis();
       try
       {
          /////////////////////////////////////////////////////////////////////////////////////////////////
@@ -193,9 +190,6 @@ public class QInstanceValidator
          validateUniqueTopLevelNames(qInstance);
 
          runPlugins(QInstance.class, qInstance, qInstance);
-
-         long end = System.currentTimeMillis();
-         LOG.info("Validation (and enrichment) performance", logPair("millis", (end - start)));
       }
       catch(Exception e)
       {
@@ -214,17 +208,6 @@ public class QInstanceValidator
 
 
 
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   public void revalidate(QInstance qInstance) throws QInstanceValidationException
-   {
-      qInstance.setHasBeenValidated(null);
-      validate(qInstance);
-   }
-
-
-
    /*******************************************************************************
     **
     *******************************************************************************/
@@ -641,11 +624,6 @@ public class QInstanceValidator
                supplementalTableMetaData.validate(qInstance, table, this);
             }
 
-            if(table.getShareableTableMetaData() != null)
-            {
-               table.getShareableTableMetaData().validate(qInstance, table, this);
-            }
-
             runPlugins(QTableMetaData.class, table, qInstance);
          });
       }
@@ -673,20 +651,17 @@ public class QInstanceValidator
             {
                if(assertCondition(CollectionUtils.nullSafeHasContents(exposedJoin.getJoinPath()), joinPrefix + "is missing a joinPath."))
                {
-                  if(joinGraph != null)
-                  {
-                     joinConnectionsForTable = Objects.requireNonNullElseGet(joinConnectionsForTable, () -> joinGraph.getJoinConnections(table.getName()));
+                  joinConnectionsForTable = Objects.requireNonNullElseGet(joinConnectionsForTable, () -> joinGraph.getJoinConnections(table.getName()));
 
-                     boolean foundJoinConnection = false;
-                     for(JoinGraph.JoinConnectionList joinConnectionList : joinConnectionsForTable)
+                  boolean foundJoinConnection = false;
+                  for(JoinGraph.JoinConnectionList joinConnectionList : joinConnectionsForTable)
+                  {
+                     if(joinConnectionList.matchesJoinPath(exposedJoin.getJoinPath()))
                      {
-                        if(joinConnectionList.matchesJoinPath(exposedJoin.getJoinPath()))
-                        {
-                           foundJoinConnection = true;
-                        }
+                        foundJoinConnection = true;
                      }
-                     assertCondition(foundJoinConnection, joinPrefix + "specified a joinPath [" + exposedJoin.getJoinPath() + "] which does not match a valid join connection in the instance.");
                   }
+                  assertCondition(foundJoinConnection, joinPrefix + "specified a joinPath [" + exposedJoin.getJoinPath() + "] which does not match a valid join connection in the instance.");
 
                   assertCondition(!usedJoinPaths.contains(exposedJoin.getJoinPath()), tablePrefix + "has more than one join with the joinPath: " + exposedJoin.getJoinPath());
                   usedJoinPaths.add(exposedJoin.getJoinPath());
@@ -736,6 +711,7 @@ public class QInstanceValidator
    {
       String prefix = "Table " + table.getName() + " ";
 
+      RECORD_SECURITY_LOCKS_LOOP:
       for(RecordSecurityLock recordSecurityLock : CollectionUtils.nonNullList(table.getRecordSecurityLocks()))
       {
          if(!assertCondition(recordSecurityLock != null, prefix + "has a null recordSecurityLock (did you mean to give it a null list of locks?)"))
@@ -743,129 +719,91 @@ public class QInstanceValidator
             continue;
          }
 
-         if(recordSecurityLock instanceof MultiRecordSecurityLock multiRecordSecurityLock)
+         String securityKeyTypeName = recordSecurityLock.getSecurityKeyType();
+         if(assertCondition(StringUtils.hasContent(securityKeyTypeName), prefix + "has a recordSecurityLock that is missing a securityKeyType"))
          {
-            validateMultiRecordSecurityLock(qInstance, table, multiRecordSecurityLock, prefix);
+            assertCondition(qInstance.getSecurityKeyType(securityKeyTypeName) != null, prefix + "has a recordSecurityLock with an unrecognized securityKeyType: " + securityKeyTypeName);
          }
-         else
+
+         prefix = "Table " + table.getName() + " recordSecurityLock (of key type " + securityKeyTypeName + ") ";
+
+         assertCondition(recordSecurityLock.getLockScope() != null, prefix + " is missing its lockScope");
+
+         boolean hasAnyBadJoins = false;
+         for(String joinName : CollectionUtils.nonNullList(recordSecurityLock.getJoinNameChain()))
          {
-            validateRecordSecurityLock(qInstance, table, recordSecurityLock, prefix);
-         }
-      }
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   private void validateMultiRecordSecurityLock(QInstance qInstance, QTableMetaData table, MultiRecordSecurityLock multiRecordSecurityLock, String prefix)
-   {
-      assertCondition(multiRecordSecurityLock.getOperator() != null, prefix + "has a MultiRecordSecurityLock that is missing an operator");
-
-      for(RecordSecurityLock lock : multiRecordSecurityLock.getLocks())
-      {
-         validateRecordSecurityLock(qInstance, table, lock, prefix);
-      }
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   private void validateRecordSecurityLock(QInstance qInstance, QTableMetaData table, RecordSecurityLock recordSecurityLock, String prefix)
-   {
-      String securityKeyTypeName = recordSecurityLock.getSecurityKeyType();
-      if(assertCondition(StringUtils.hasContent(securityKeyTypeName), prefix + "has a recordSecurityLock that is missing a securityKeyType"))
-      {
-         assertCondition(qInstance.getSecurityKeyType(securityKeyTypeName) != null, prefix + "has a recordSecurityLock with an unrecognized securityKeyType: " + securityKeyTypeName);
-      }
-
-      prefix = "Table " + table.getName() + " recordSecurityLock (of key type " + securityKeyTypeName + ") ";
-
-      assertCondition(recordSecurityLock.getLockScope() != null, prefix + " is missing its lockScope");
-
-      boolean hasAnyBadJoins = false;
-      for(String joinName : CollectionUtils.nonNullList(recordSecurityLock.getJoinNameChain()))
-      {
-         if(!assertCondition(qInstance.getJoin(joinName) != null, prefix + "has an unrecognized joinName: " + joinName))
-         {
-            hasAnyBadJoins = true;
-         }
-      }
-
-      String fieldName = recordSecurityLock.getFieldName();
-
-      ////////////////////////////////////////////////////////////////////////////////
-      // don't bother trying to validate field names if we know we have a bad join. //
-      ////////////////////////////////////////////////////////////////////////////////
-      if(assertCondition(StringUtils.hasContent(fieldName), prefix + "is missing a fieldName") && !hasAnyBadJoins)
-      {
-         if(fieldName.contains("."))
-         {
-            if(assertCondition(CollectionUtils.nullSafeHasContents(recordSecurityLock.getJoinNameChain()), prefix + "field name " + fieldName + " looks like a join (has a dot), but no joinNameChain was given."))
+            if(!assertCondition(qInstance.getJoin(joinName) != null, prefix + "has an unrecognized joinName: " + joinName))
             {
-               String[] split         = fieldName.split("\\.");
-               String   joinTableName = split[0];
-               String   joinFieldName = split[1];
+               hasAnyBadJoins = true;
+            }
+         }
 
-               List<QueryJoin> joins = new ArrayList<>();
+         String fieldName = recordSecurityLock.getFieldName();
 
-               ///////////////////////////////////////////////////////////////////////////////////////////////////
-               // ok - so - the join name chain is going to be like this:                                       //
-               // for a table:  orderLineItemExtrinsic (that's 2 away from order, where the security field is): //
-               // - securityFieldName = order.clientId                                                          //
-               // - joinNameChain = orderJoinOrderLineItem, orderLineItemJoinOrderLineItemExtrinsic             //
-               // so - to navigate from the table to the security field, we need to reverse the joinNameChain,  //
-               // and step (via tmpTable variable) back to the securityField                                    //
-               ///////////////////////////////////////////////////////////////////////////////////////////////////
-               ArrayList<String> joinNameChain = new ArrayList<>(CollectionUtils.nonNullList(recordSecurityLock.getJoinNameChain()));
-               Collections.reverse(joinNameChain);
-
-               QTableMetaData tmpTable = table;
-
-               for(String joinName : joinNameChain)
+         ////////////////////////////////////////////////////////////////////////////////
+         // don't bother trying to validate field names if we know we have a bad join. //
+         ////////////////////////////////////////////////////////////////////////////////
+         if(assertCondition(StringUtils.hasContent(fieldName), prefix + "is missing a fieldName") && !hasAnyBadJoins)
+         {
+            if(fieldName.contains("."))
+            {
+               if(assertCondition(CollectionUtils.nullSafeHasContents(recordSecurityLock.getJoinNameChain()), prefix + "field name " + fieldName + " looks like a join (has a dot), but no joinNameChain was given."))
                {
-                  QJoinMetaData join = qInstance.getJoin(joinName);
-                  if(join == null)
+                  List<QueryJoin> joins = new ArrayList<>();
+
+                  ///////////////////////////////////////////////////////////////////////////////////////////////////
+                  // ok - so - the join name chain is going to be like this:                                       //
+                  // for a table:  orderLineItemExtrinsic (that's 2 away from order, where the security field is): //
+                  // - securityFieldName = order.clientId                                                          //
+                  // - joinNameChain = orderJoinOrderLineItem, orderLineItemJoinOrderLineItemExtrinsic             //
+                  // so - to navigate from the table to the security field, we need to reverse the joinNameChain,  //
+                  // and step (via tmpTable variable) back to the securityField                                    //
+                  ///////////////////////////////////////////////////////////////////////////////////////////////////
+                  ArrayList<String> joinNameChain = new ArrayList<>(CollectionUtils.nonNullList(recordSecurityLock.getJoinNameChain()));
+                  Collections.reverse(joinNameChain);
+
+                  QTableMetaData tmpTable = table;
+
+                  for(String joinName : joinNameChain)
                   {
-                     errors.add(prefix + "joinNameChain contained an unrecognized join: " + joinName);
-                     return;
+                     QJoinMetaData join = qInstance.getJoin(joinName);
+                     if(join == null)
+                     {
+                        errors.add(prefix + "joinNameChain contained an unrecognized join: " + joinName);
+                        continue RECORD_SECURITY_LOCKS_LOOP;
+                     }
+
+                     if(join.getLeftTable().equals(tmpTable.getName()))
+                     {
+                        joins.add(new QueryJoin(join));
+                        tmpTable = qInstance.getTable(join.getRightTable());
+                     }
+                     else if(join.getRightTable().equals(tmpTable.getName()))
+                     {
+                        joins.add(new QueryJoin(join.flip()));
+                        tmpTable = qInstance.getTable(join.getLeftTable());
+                     }
+                     else
+                     {
+                        errors.add(prefix + "joinNameChain could not be followed through join: " + joinName);
+                        continue RECORD_SECURITY_LOCKS_LOOP;
+                     }
                   }
 
-                  if(join.getLeftTable().equals(tmpTable.getName()))
-                  {
-                     joins.add(new QueryJoin(join));
-                     tmpTable = qInstance.getTable(join.getRightTable());
-                  }
-                  else if(join.getRightTable().equals(tmpTable.getName()))
-                  {
-                     joins.add(new QueryJoin(join.flip()));
-                     tmpTable = qInstance.getTable(join.getLeftTable());
-                  }
-                  else
-                  {
-                     errors.add(prefix + "joinNameChain could not be followed through join: " + joinName);
-                     return;
-                  }
+                  assertCondition(findField(qInstance, table, joins, fieldName), prefix + "has an unrecognized fieldName: " + fieldName);
                }
-
-               assertCondition(Objects.equals(tmpTable.getName(), joinTableName), prefix + "has a joinNameChain doesn't end in the expected table [" + joinTableName + "] (was: " + tmpTable.getName() + ")");
-
-               assertCondition(findField(qInstance, table, joins, fieldName), prefix + "has an unrecognized fieldName: " + fieldName);
             }
-         }
-         else
-         {
-            if(assertCondition(CollectionUtils.nullSafeIsEmpty(recordSecurityLock.getJoinNameChain()), prefix + "field name " + fieldName + " does not look like a join (does not have a dot), but a joinNameChain was given."))
+            else
             {
-               assertNoException(() -> table.getField(fieldName), prefix + "has an unrecognized fieldName: " + fieldName);
+               if(assertCondition(CollectionUtils.nullSafeIsEmpty(recordSecurityLock.getJoinNameChain()), prefix + "field name " + fieldName + " does not look like a join (does not have a dot), but a joinNameChain was given."))
+               {
+                  assertNoException(() -> table.getField(fieldName), prefix + "has an unrecognized fieldName: " + fieldName);
+               }
             }
          }
-      }
 
-      assertCondition(recordSecurityLock.getNullValueBehavior() != null, prefix + "is missing a nullValueBehavior");
+         assertCondition(recordSecurityLock.getNullValueBehavior() != null, prefix + "is missing a nullValueBehavior");
+      }
    }
 
 
@@ -1487,7 +1425,7 @@ public class QInstanceValidator
                                  warn("Error loading expectedType for field [" + fieldMetaData.getName() + "] in process [" + processName + "]: " + e.getMessage());
                               }
 
-                              validateSimpleCodeReference("Process " + processName + " code reference:", codeReference, expectedClass);
+                              validateSimpleCodeReference("Process " + processName + " code reference: ", codeReference, expectedClass);
                            }
                         }
                      }
@@ -1495,14 +1433,6 @@ public class QInstanceValidator
                }
             }
 
-            if(process.getCancelStep() != null)
-            {
-               if(assertCondition(process.getCancelStep().getCode() != null, "Cancel step is missing a code reference, in process " + processName))
-               {
-                  validateSimpleCodeReference("Process " + processName + " cancel step code reference: ", process.getCancelStep().getCode(), BackendStep.class);
-               }
-            }
-
             ///////////////////////////////////////////////////////////////////////////////
             // if the process has a schedule, make sure required schedule data populated //
             ///////////////////////////////////////////////////////////////////////////////
@@ -1514,11 +1444,7 @@ public class QInstanceValidator
 
             if(process.getVariantBackend() != null)
             {
-               if(qInstance.getBackends() != null)
-               {
-                  assertCondition(qInstance.getBackend(process.getVariantBackend()) != null, "Process " + processName + ", a variant backend was not found named " + process.getVariantBackend());
-               }
-
+               assertCondition(qInstance.getBackend(process.getVariantBackend()) != null, "Process " + processName + ", a variant backend was not found named " + process.getVariantBackend());
                assertCondition(process.getVariantRunStrategy() != null, "A variant run strategy was not set for process " + processName + " (which does specify a variant backend)");
             }
             else

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/logging/LogPair.java

@@ -79,7 +79,7 @@ public class LogPair
       }
       else if(value instanceof LogPair[] subLogPairs)
       {
-         String subLogPairsString = Arrays.stream(subLogPairs).filter(Objects::nonNull).map(LogPair::toString).collect(Collectors.joining(","));
+         String subLogPairsString = Arrays.stream(subLogPairs).map(LogPair::toString).collect(Collectors.joining(","));
          valueString = '{' + subLogPairsString + '}';
       }
       else if(value instanceof UnsafeSupplier<?, ?> us)

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/logging/QLogger.java

@@ -22,7 +22,6 @@
 package com.kingsrook.qqq.backend.core.logging;
 
 
-import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
@@ -148,28 +147,6 @@ public class QLogger
 
 
 
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   public <T extends Throwable> T warnAndThrow(T t, LogPair... logPairs) throws T
-   {
-      warn(t.getMessage(), t, logPairs);
-      throw (t);
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   public <T extends Throwable> T errorAndThrow(T t, LogPair... logPairs) throws T
-   {
-      error(t.getMessage(), t, logPairs);
-      throw (t);
-   }
-
-
-
    /*******************************************************************************
     **
     *******************************************************************************/
@@ -618,10 +595,7 @@ public class QLogger
             {
                user = session.getUser().getIdReference();
             }
-
-            LogPair variantsLogPair = getVariantsLogPair(session);
-
-            sessionLogPair = logPair("session", logPair("id", session.getUuid()), logPair("user", user), variantsLogPair);
+            sessionLogPair = logPair("session", logPair("id", session.getUuid()), logPair("user", user));
          }
 
          try
@@ -641,38 +615,6 @@ public class QLogger
 
 
 
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   private static LogPair getVariantsLogPair(QSession session)
-   {
-      LogPair variantsLogPair = null;
-      try
-      {
-         if(session.getBackendVariants() != null)
-         {
-            LogPair[] variants = new LogPair[session.getBackendVariants().size()];
-
-            int i = 0;
-            for(Map.Entry<String, Serializable> entry : session.getBackendVariants().entrySet())
-            {
-               variants[i] = new LogPair(entry.getKey(), entry.getValue());
-            }
-
-            variantsLogPair = new LogPair("variants", variants);
-         }
-      }
-      catch(Exception e)
-      {
-         ////////////////
-         // leave null //
-         ////////////////
-      }
-      return variantsLogPair;
-   }
-
-
-
    /*******************************************************************************
     **
     *******************************************************************************/

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/MetaDataProducerInterface.java

@@ -23,8 +23,8 @@ package com.kingsrook.qqq.backend.core.model;
 
 
 import com.kingsrook.qqq.backend.core.exceptions.QException;
-import com.kingsrook.qqq.backend.core.model.metadata.MetaDataProducerOutput;
 import com.kingsrook.qqq.backend.core.model.metadata.QInstance;
+import com.kingsrook.qqq.backend.core.model.metadata.TopLevelMetaDataInterface;
 
 
 /*******************************************************************************
@@ -42,7 +42,7 @@ import com.kingsrook.qqq.backend.core.model.metadata.QInstance;
  ** implement this interface.  or, same idea for a QRecordEntity that provides
  ** its own TableMetaData.
  *******************************************************************************/
-public interface MetaDataProducerInterface<T extends MetaDataProducerOutput>
+public interface MetaDataProducerInterface<T extends TopLevelMetaDataInterface>
 {
    int DEFAULT_SORT_ORDER = 500;
 

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/actions/messaging/Attachment.java

@@ -1,95 +0,0 @@
-/*
- * QQQ - Low-code Application Framework for Engineers.
- * Copyright (C) 2021-2024.  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.model.actions.messaging;
-
-
-/*******************************************************************************
- **
- *******************************************************************************/
-public class Attachment
-{
-   private byte[] contents;
-   private String name;
-
-
-
-   /*******************************************************************************
-    ** Getter for contents
-    *******************************************************************************/
-   public byte[] getContents()
-   {
-      return (this.contents);
-   }
-
-
-
-   /*******************************************************************************
-    ** Setter for contents
-    *******************************************************************************/
-   public void setContents(byte[] contents)
-   {
-      this.contents = contents;
-   }
-
-
-
-   /*******************************************************************************
-    ** Fluent setter for contents
-    *******************************************************************************/
-   public Attachment withContents(byte[] contents)
-   {
-      this.contents = contents;
-      return (this);
-   }
-
-
-
-   /*******************************************************************************
-    ** Getter for name
-    *******************************************************************************/
-   public String getName()
-   {
-      return (this.name);
-   }
-
-
-
-   /*******************************************************************************
-    ** Setter for name
-    *******************************************************************************/
-   public void setName(String name)
-   {
-      this.name = name;
-   }
-
-
-
-   /*******************************************************************************
-    ** Fluent setter for name
-    *******************************************************************************/
-   public Attachment withName(String name)
-   {
-      this.name = name;
-      return (this);
-   }
-
-}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/actions/messaging/Content.java

@@ -1,95 +0,0 @@
-/*
- * QQQ - Low-code Application Framework for Engineers.
- * Copyright (C) 2021-2024.  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.model.actions.messaging;
-
-
-/*******************************************************************************
- **
- *******************************************************************************/
-public class Content
-{
-   private String      body;
-   private ContentRole contentRole;
-
-
-
-   /*******************************************************************************
-    ** Getter for body
-    *******************************************************************************/
-   public String getBody()
-   {
-      return (this.body);
-   }
-
-
-
-   /*******************************************************************************
-    ** Setter for body
-    *******************************************************************************/
-   public void setBody(String body)
-   {
-      this.body = body;
-   }
-
-
-
-   /*******************************************************************************
-    ** Fluent setter for body
-    *******************************************************************************/
-   public Content withBody(String body)
-   {
-      this.body = body;
-      return (this);
-   }
-
-
-
-   /*******************************************************************************
-    ** Getter for contentRole
-    *******************************************************************************/
-   public ContentRole getContentRole()
-   {
-      return (this.contentRole);
-   }
-
-
-
-   /*******************************************************************************
-    ** Setter for contentRole
-    *******************************************************************************/
-   public void setContentRole(ContentRole contentRole)
-   {
-      this.contentRole = contentRole;
-   }
-
-
-
-   /*******************************************************************************
-    ** Fluent setter for contentRole
-    *******************************************************************************/
-   public Content withContentRole(ContentRole contentRole)
-   {
-      this.contentRole = contentRole;
-      return (this);
-   }
-
-}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/actions/messaging/ContentRole.java

@@ -1,39 +0,0 @@
-/*
- * QQQ - Low-code Application Framework for Engineers.
- * Copyright (C) 2021-2024.  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.model.actions.messaging;
-
-
-/*******************************************************************************
- **
- *******************************************************************************/
-public interface ContentRole
-{
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   enum Default implements ContentRole
-   {
-      DEFAULT
-   }
-
-}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/actions/messaging/MultiParty.java

@@ -1,92 +0,0 @@
-/*
- * QQQ - Low-code Application Framework for Engineers.
- * Copyright (C) 2021-2024.  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.model.actions.messaging;
-
-
-import java.util.ArrayList;
-import java.util.List;
-
-
-/*******************************************************************************
- **
- *******************************************************************************/
-public class MultiParty extends Party
-{
-   private List<Party> partyList;
-
-
-
-   /*******************************************************************************
-    ** Getter for partyList
-    *******************************************************************************/
-   public List<Party> getPartyList()
-   {
-      return (this.partyList);
-   }
-
-
-
-   /*******************************************************************************
-    ** Setter for partyList
-    *******************************************************************************/
-   public void setPartyList(List<Party> partyList)
-   {
-      this.partyList = partyList;
-   }
-
-
-
-   /*******************************************************************************
-    ** Fluent setter for partyList
-    *******************************************************************************/
-   public MultiParty withPartyList(List<Party> partyList)
-   {
-      this.partyList = partyList;
-      return (this);
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   public MultiParty withParty(Party party)
-   {
-      addParty(party);
-      return (this);
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   public void addParty(Party party)
-   {
-      if(this.partyList == null)
-      {
-         this.partyList = new ArrayList<>();
-      }
-      this.partyList.add(party);
-   }
-
-}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/actions/messaging/Party.java

@@ -1,127 +0,0 @@
-/*
- * QQQ - Low-code Application Framework for Engineers.
- * Copyright (C) 2021-2024.  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.model.actions.messaging;
-
-
-/*******************************************************************************
- **
- *******************************************************************************/
-public class Party
-{
-   private String    label;
-   private String    address;
-   private PartyRole role;
-
-
-
-   /*******************************************************************************
-    ** Getter for label
-    *******************************************************************************/
-   public String getLabel()
-   {
-      return (this.label);
-   }
-
-
-
-   /*******************************************************************************
-    ** Setter for label
-    *******************************************************************************/
-   public void setLabel(String label)
-   {
-      this.label = label;
-   }
-
-
-
-   /*******************************************************************************
-    ** Fluent setter for label
-    *******************************************************************************/
-   public Party withLabel(String label)
-   {
-      this.label = label;
-      return (this);
-   }
-
-
-
-   /*******************************************************************************
-    ** Getter for address
-    *******************************************************************************/
-   public String getAddress()
-   {
-      return (this.address);
-   }
-
-
-
-   /*******************************************************************************
-    ** Setter for address
-    *******************************************************************************/
-   public void setAddress(String address)
-   {
-      this.address = address;
-   }
-
-
-
-   /*******************************************************************************
-    ** Fluent setter for address
-    *******************************************************************************/
-   public Party withAddress(String address)
-   {
-      this.address = address;
-      return (this);
-   }
-
-
-
-   /*******************************************************************************
-    ** Getter for role
-    *******************************************************************************/
-   public PartyRole getRole()
-   {
-      return (this.role);
-   }
-
-
-
-   /*******************************************************************************
-    ** Setter for role
-    *******************************************************************************/
-   public void setRole(PartyRole role)
-   {
-      this.role = role;
-   }
-
-
-
-   /*******************************************************************************
-    ** Fluent setter for role
-    *******************************************************************************/
-   public Party withRole(PartyRole role)
-   {
-      this.role = role;
-      return (this);
-   }
-
-}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/actions/messaging/PartyRole.java

@@ -1,39 +0,0 @@
-/*
- * QQQ - Low-code Application Framework for Engineers.
- * Copyright (C) 2021-2024.  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.model.actions.messaging;
-
-
-/*******************************************************************************
- **
- *******************************************************************************/
-public interface PartyRole
-{
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   enum Default implements PartyRole
-   {
-      DEFAULT
-   }
-
-}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/actions/messaging/SendMessageInput.java

@@ -1,278 +0,0 @@
-/*
- * QQQ - Low-code Application Framework for Engineers.
- * Copyright (C) 2021-2024.  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.model.actions.messaging;
-
-
-import java.util.ArrayList;
-import java.util.List;
-import com.kingsrook.qqq.backend.core.model.actions.AbstractActionInput;
-
-
-/*******************************************************************************
- **
- *******************************************************************************/
-public class SendMessageInput extends AbstractActionInput
-{
-   private String           messagingProviderName;
-   private Party            to;
-   private Party            from;
-   private String           subject;
-   private List<Content>    contentList;
-   private List<Attachment> attachmentList;
-
-
-
-   /*******************************************************************************
-    ** Getter for to
-    *******************************************************************************/
-   public Party getTo()
-   {
-      return (this.to);
-   }
-
-
-
-   /*******************************************************************************
-    ** Setter for to
-    *******************************************************************************/
-   public void setTo(Party to)
-   {
-      this.to = to;
-   }
-
-
-
-   /*******************************************************************************
-    ** Fluent setter for to
-    *******************************************************************************/
-   public SendMessageInput withTo(Party to)
-   {
-      this.to = to;
-      return (this);
-   }
-
-
-
-   /*******************************************************************************
-    ** Getter for from
-    *******************************************************************************/
-   public Party getFrom()
-   {
-      return (this.from);
-   }
-
-
-
-   /*******************************************************************************
-    ** Setter for from
-    *******************************************************************************/
-   public void setFrom(Party from)
-   {
-      this.from = from;
-   }
-
-
-
-   /*******************************************************************************
-    ** Fluent setter for from
-    *******************************************************************************/
-   public SendMessageInput withFrom(Party from)
-   {
-      this.from = from;
-      return (this);
-   }
-
-
-
-   /*******************************************************************************
-    ** Getter for subject
-    *******************************************************************************/
-   public String getSubject()
-   {
-      return (this.subject);
-   }
-
-
-
-   /*******************************************************************************
-    ** Setter for subject
-    *******************************************************************************/
-   public void setSubject(String subject)
-   {
-      this.subject = subject;
-   }
-
-
-
-   /*******************************************************************************
-    ** Fluent setter for subject
-    *******************************************************************************/
-   public SendMessageInput withSubject(String subject)
-   {
-      this.subject = subject;
-      return (this);
-   }
-
-
-
-   /*******************************************************************************
-    ** Getter for contentList
-    *******************************************************************************/
-   public List<Content> getContentList()
-   {
-      return (this.contentList);
-   }
-
-
-
-   /*******************************************************************************
-    ** Setter for contentList
-    *******************************************************************************/
-   public void setContentList(List<Content> contentList)
-   {
-      this.contentList = contentList;
-   }
-
-
-
-   /*******************************************************************************
-    ** Fluent setter for contentList
-    *******************************************************************************/
-   public SendMessageInput withContentList(List<Content> contentList)
-   {
-      this.contentList = contentList;
-      return (this);
-   }
-
-
-
-   /*******************************************************************************
-    ** Getter for attachmentList
-    *******************************************************************************/
-   public List<Attachment> getAttachmentList()
-   {
-      return (this.attachmentList);
-   }
-
-
-
-   /*******************************************************************************
-    ** Setter for attachmentList
-    *******************************************************************************/
-   public void setAttachmentList(List<Attachment> attachmentList)
-   {
-      this.attachmentList = attachmentList;
-   }
-
-
-
-   /*******************************************************************************
-    ** Fluent setter for attachmentList
-    *******************************************************************************/
-   public SendMessageInput withAttachmentList(List<Attachment> attachmentList)
-   {
-      this.attachmentList = attachmentList;
-      return (this);
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   public SendMessageInput withContent(Content content)
-   {
-      addContent(content);
-      return (this);
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   public void addContent(Content content)
-   {
-      if(this.contentList == null)
-      {
-         this.contentList = new ArrayList<>();
-      }
-      this.contentList.add(content);
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   public SendMessageInput withAttachment(Attachment attachment)
-   {
-      addAttachment(attachment);
-      return (this);
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   public void addAttachment(Attachment attachment)
-   {
-      if(this.attachmentList == null)
-      {
-         this.attachmentList = new ArrayList<>();
-      }
-      this.attachmentList.add(attachment);
-   }
-
-
-
-   /*******************************************************************************
-    ** Getter for messagingProviderName
-    *******************************************************************************/
-   public String getMessagingProviderName()
-   {
-      return (this.messagingProviderName);
-   }
-
-
-
-   /*******************************************************************************
-    ** Setter for messagingProviderName
-    *******************************************************************************/
-   public void setMessagingProviderName(String messagingProviderName)
-   {
-      this.messagingProviderName = messagingProviderName;
-   }
-
-
-
-   /*******************************************************************************
-    ** Fluent setter for messagingProviderName
-    *******************************************************************************/
-   public SendMessageInput withMessagingProviderName(String messagingProviderName)
-   {
-      this.messagingProviderName = messagingProviderName;
-      return (this);
-   }
-
-}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/actions/messaging/SendMessageOutput.java

@@ -1,33 +0,0 @@
-/*
- * QQQ - Low-code Application Framework for Engineers.
- * Copyright (C) 2021-2024.  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.model.actions.messaging;
-
-
-import com.kingsrook.qqq.backend.core.model.actions.AbstractActionOutput;
-
-
-/*******************************************************************************
- **
- *******************************************************************************/
-public class SendMessageOutput extends AbstractActionOutput
-{
-}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/actions/messaging/email/EmailContentRole.java

@@ -1,35 +0,0 @@
-/*
- * QQQ - Low-code Application Framework for Engineers.
- * Copyright (C) 2021-2024.  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.model.actions.messaging.email;
-
-
-import com.kingsrook.qqq.backend.core.model.actions.messaging.ContentRole;
-
-
-/*******************************************************************************
- **
- *******************************************************************************/
-public enum EmailContentRole implements ContentRole
-{
-   TEXT,
-   HTML
-}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/actions/messaging/email/EmailPartyRole.java

@@ -1,38 +0,0 @@
-/*
- * QQQ - Low-code Application Framework for Engineers.
- * Copyright (C) 2021-2024.  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.model.actions.messaging.email;
-
-
-import com.kingsrook.qqq.backend.core.model.actions.messaging.PartyRole;
-
-
-/*******************************************************************************
- **
- *******************************************************************************/
-public enum EmailPartyRole implements PartyRole
-{
-   TO,
-   CC,
-   BCC,
-   FROM,
-   REPLY_TO
-}

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

@@ -29,7 +29,6 @@ import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import com.kingsrook.qqq.backend.core.model.data.QRecord;
-import com.kingsrook.qqq.backend.core.model.metadata.processes.QFrontendStepMetaData;
 
 
 /*******************************************************************************
@@ -42,11 +41,6 @@ public class ProcessState implements Serializable
    private List<String>              stepList     = new ArrayList<>();
    private Optional<String>          nextStepName = Optional.empty();
 
-   /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-   // maybe, remove this altogether - just let the frontend compute & send if needed... but how does it know last version...? //
-   /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-   private List<QFrontendStepMetaData> updatedFrontendStepList = null;
-
 
 
    /*******************************************************************************
@@ -145,36 +139,4 @@ public class ProcessState implements Serializable
    {
       this.stepList = stepList;
    }
-
-
-
-   /*******************************************************************************
-    ** Getter for updatedFrontendStepList
-    *******************************************************************************/
-   public List<QFrontendStepMetaData> getUpdatedFrontendStepList()
-   {
-      return (this.updatedFrontendStepList);
-   }
-
-
-
-   /*******************************************************************************
-    ** Setter for updatedFrontendStepList
-    *******************************************************************************/
-   public void setUpdatedFrontendStepList(List<QFrontendStepMetaData> updatedFrontendStepList)
-   {
-      this.updatedFrontendStepList = updatedFrontendStepList;
-   }
-
-
-
-   /*******************************************************************************
-    ** Fluent setter for updatedFrontendStepList
-    *******************************************************************************/
-   public ProcessState withUpdatedFrontendStepList(List<QFrontendStepMetaData> updatedFrontendStepList)
-   {
-      this.updatedFrontendStepList = updatedFrontendStepList;
-      return (this);
-   }
-
 }

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

@@ -27,14 +27,10 @@ import java.math.BigDecimal;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
-import com.kingsrook.qqq.backend.core.context.QContext;
-import com.kingsrook.qqq.backend.core.exceptions.QRuntimeException;
 import com.kingsrook.qqq.backend.core.model.actions.AbstractActionOutput;
 import com.kingsrook.qqq.backend.core.model.actions.audits.AuditInput;
 import com.kingsrook.qqq.backend.core.model.actions.audits.AuditSingleInput;
 import com.kingsrook.qqq.backend.core.model.data.QRecord;
-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.utils.ValueUtils;
 
 
@@ -44,13 +40,9 @@ import com.kingsrook.qqq.backend.core.utils.ValueUtils;
  *******************************************************************************/
 public class RunBackendStepOutput extends AbstractActionOutput implements Serializable
 {
-   private String processName;
-
    private ProcessState processState;
    private Exception    exception; // todo - make optional
 
-   private String overrideLastStepName; // todo - does this need to go into state too??
-
    private List<AuditInput> auditInputList = new ArrayList<>();
 
 
@@ -86,7 +78,6 @@ public class RunBackendStepOutput extends AbstractActionOutput implements Serial
    public void seedFromRequest(RunBackendStepInput runBackendStepInput)
    {
       this.processState = runBackendStepInput.getProcessState();
-      this.processName = runBackendStepInput.getProcessName();
    }
 
 
@@ -321,111 +312,4 @@ public class RunBackendStepOutput extends AbstractActionOutput implements Serial
       auditInput.addAuditSingleInput(auditSingleInput);
    }
 
-
-
-   /*******************************************************************************
-    ** Getter for overrideLastStepName
-    *******************************************************************************/
-   public String getOverrideLastStepName()
-   {
-      return (this.overrideLastStepName);
-   }
-
-
-
-   /*******************************************************************************
-    ** Setter for overrideLastStepName
-    *******************************************************************************/
-   public void setOverrideLastStepName(String overrideLastStepName)
-   {
-      this.overrideLastStepName = overrideLastStepName;
-   }
-
-
-
-   /*******************************************************************************
-    ** Fluent setter for overrideLastStepName
-    *******************************************************************************/
-   public RunBackendStepOutput withOverrideLastStepName(String overrideLastStepName)
-   {
-      this.overrideLastStepName = overrideLastStepName;
-      return (this);
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   public void updateStepList(List<String> stepList)
-   {
-      getProcessState().setStepList(stepList);
-
-      if(processName == null)
-      {
-         throw (new QRuntimeException("ProcessName was not set in this object, therefore updateStepList cannot complete successfully.  Try to manually call setProcessName as a work around."));
-      }
-
-      QProcessMetaData processMetaData = QContext.getQInstance().getProcess(processName);
-
-      ArrayList<QFrontendStepMetaData> updatedFrontendStepList = new ArrayList<>(stepList.stream()
-         .map(name -> processMetaData.getStep(name))
-         .filter(step -> step instanceof QFrontendStepMetaData)
-         .map(step -> (QFrontendStepMetaData) step)
-         .toList());
-
-      setUpdatedFrontendStepList(updatedFrontendStepList);
-   }
-
-
-
-   /*******************************************************************************
-    ** Getter for processName
-    *******************************************************************************/
-   public String getProcessName()
-   {
-      return (this.processName);
-   }
-
-
-
-   /*******************************************************************************
-    ** Setter for processName
-    *******************************************************************************/
-   public void setProcessName(String processName)
-   {
-      this.processName = processName;
-   }
-
-
-
-   /*******************************************************************************
-    ** Fluent setter for processName
-    *******************************************************************************/
-   public RunBackendStepOutput withProcessName(String processName)
-   {
-      this.processName = processName;
-      return (this);
-   }
-
-
-
-   /*******************************************************************************
-    ** Getter for updatedFrontendStepList
-    *******************************************************************************/
-   public List<QFrontendStepMetaData> getUpdatedFrontendStepList()
-   {
-      return (this.processState.getUpdatedFrontendStepList());
-   }
-
-
-
-   /*******************************************************************************
-    ** Setter for updatedFrontendStepList
-    *******************************************************************************/
-   public void setUpdatedFrontendStepList(List<QFrontendStepMetaData> updatedFrontendStepList)
-   {
-      this.processState.setUpdatedFrontendStepList(updatedFrontendStepList);
-   }
-
 }

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

@@ -32,7 +32,6 @@ import java.util.Map;
 import java.util.Optional;
 import com.kingsrook.qqq.backend.core.model.actions.AbstractActionOutput;
 import com.kingsrook.qqq.backend.core.model.data.QRecord;
-import com.kingsrook.qqq.backend.core.model.metadata.processes.QFrontendStepMetaData;
 import com.kingsrook.qqq.backend.core.utils.ValueUtils;
 
 
@@ -328,25 +327,4 @@ public class RunProcessOutput extends AbstractActionOutput implements Serializab
    {
       return exception;
    }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   public void setUpdatedFrontendStepList(List<QFrontendStepMetaData> updatedFrontendStepList)
-   {
-      this.processState.setUpdatedFrontendStepList(updatedFrontendStepList);
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   public List<QFrontendStepMetaData> getUpdatedFrontendStepList()
-   {
-      return this.processState.getUpdatedFrontendStepList();
-   }
-
 }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/actions/tables/delete/DeleteInput.java

@@ -23,7 +23,6 @@ package com.kingsrook.qqq.backend.core.model.actions.tables.delete;
 
 
 import java.io.Serializable;
-import java.util.ArrayList;
 import java.util.List;
 import com.kingsrook.qqq.backend.core.actions.QBackendTransaction;
 import com.kingsrook.qqq.backend.core.model.actions.AbstractTableActionInput;
@@ -140,24 +139,6 @@ public class DeleteInput extends AbstractTableActionInput
 
 
 
-   /*******************************************************************************
-    ** Fluently add 1 primary key to the delete input
-    **
-    *******************************************************************************/
-   public DeleteInput withPrimaryKey(Serializable primaryKey)
-   {
-      if(primaryKeys == null)
-      {
-         primaryKeys = new ArrayList<>();
-      }
-
-      primaryKeys.add(primaryKey);
-
-      return (this);
-   }
-
-
-
    /*******************************************************************************
     ** Setter for ids
     **

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/actions/tables/insert/InsertInput.java

@@ -112,7 +112,7 @@ public class InsertInput extends AbstractTableActionInput
    /*******************************************************************************
     **
     *******************************************************************************/
-   public InsertInput withRecordEntities(List<? extends QRecordEntity> recordEntityList)
+   public InsertInput withRecordEntities(List<QRecordEntity> recordEntityList)
    {
       for(QRecordEntity recordEntity : CollectionUtils.nonNullList(recordEntityList))
       {

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/actions/tables/query/JoinsContext.java

@@ -22,7 +22,6 @@
 package com.kingsrook.qqq.backend.core.model.actions.tables.query;
 
 
-import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
@@ -38,18 +37,12 @@ import com.kingsrook.qqq.backend.core.logging.LogPair;
 import com.kingsrook.qqq.backend.core.logging.QLogger;
 import com.kingsrook.qqq.backend.core.model.metadata.QInstance;
 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.QJoinMetaData;
-import com.kingsrook.qqq.backend.core.model.metadata.security.MultiRecordSecurityLock;
-import com.kingsrook.qqq.backend.core.model.metadata.security.NullValueBehaviorUtil;
-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.ExposedJoin;
 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.collections.MutableList;
 import org.apache.logging.log4j.Level;
 import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
@@ -67,23 +60,11 @@ public class JoinsContext
    private final String          mainTableName;
    private final List<QueryJoin> queryJoins;
 
-   private final QQueryFilter securityFilter;
-
-   ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-   // pointer either at securityFilter, or at a sub-filter within it, for when we're doing a recursive build-out of multi-locks //
-   ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-   private QQueryFilter securityFilterCursor;
-
    ////////////////////////////////////////////////////////////////
    // note - will have entries for all tables, not just aliases. //
    ////////////////////////////////////////////////////////////////
    private final Map<String, String> aliasToTableNameMap = new HashMap<>();
-
-   /////////////////////////////////////////////////////////////////////////////
-   // we will get a TON of more output if this gets turned up, so be cautious //
-   /////////////////////////////////////////////////////////////////////////////
-   private Level logLevel = Level.OFF;
-   private Level logLevelForFilter = Level.OFF;
+   private       Level               logLevel            = Level.OFF;
 
 
 
@@ -93,225 +74,54 @@ public class JoinsContext
     *******************************************************************************/
    public JoinsContext(QInstance instance, String tableName, List<QueryJoin> queryJoins, QQueryFilter filter) throws QException
    {
+      log("--- START ----------------------------------------------------------------------", logPair("mainTable", tableName));
       this.instance = instance;
       this.mainTableName = tableName;
       this.queryJoins = new MutableList<>(queryJoins);
-      this.securityFilter = new QQueryFilter();
-      this.securityFilterCursor = this.securityFilter;
-
-      // log("--- START ----------------------------------------------------------------------", logPair("mainTable", tableName));
-      dumpDebug(true, false);
 
       for(QueryJoin queryJoin : this.queryJoins)
       {
+         log("Processing input query join", logPair("joinTable", queryJoin.getJoinTable()), logPair("alias", queryJoin.getAlias()), logPair("baseTableOrAlias", queryJoin.getBaseTableOrAlias()), logPair("joinMetaDataName", () -> queryJoin.getJoinMetaData().getName()));
          processQueryJoin(queryJoin);
       }
 
-      /////////////////////////////////////////////////////////////////////////////////////////////////////
-      // make sure that all tables specified in filter columns are being brought into the query as joins //
-      /////////////////////////////////////////////////////////////////////////////////////////////////////
-      ensureFilterIsRepresented(filter);
-      logFilter("After ensureFilterIsRepresented:", securityFilter);
-
-      ///////////////////////////////////////////////////////////////////////////////////////
-      // ensure that any record locks on the main table, which require a join, are present //
-      ///////////////////////////////////////////////////////////////////////////////////////
-      MultiRecordSecurityLock multiRecordSecurityLock = RecordSecurityLockFilters.filterForReadLockTree(CollectionUtils.nonNullList(instance.getTable(tableName).getRecordSecurityLocks()));
-      for(RecordSecurityLock lock : multiRecordSecurityLock.getLocks())
-      {
-         ensureRecordSecurityLockIsRepresented(tableName, tableName, lock, null);
-         logFilter("After ensureRecordSecurityLockIsRepresented[fieldName=" + lock.getFieldName() + "]:", securityFilter);
-      }
-
-      ///////////////////////////////////////////////////////////////////////////////////
-      // make sure that all joins in the query have meta data specified                //
-      // e.g., a user-added join may just specify the join-table                       //
-      // or a join implicitly added from a filter may also not have its join meta data //
-      ///////////////////////////////////////////////////////////////////////////////////
-      fillInMissingJoinMetaData();
-      logFilter("After fillInMissingJoinMetaData:", securityFilter);
-
       ///////////////////////////////////////////////////////////////
       // ensure any joins that contribute a recordLock are present //
       ///////////////////////////////////////////////////////////////
-      ensureAllJoinRecordSecurityLocksAreRepresented(instance);
-      logFilter("After ensureAllJoinRecordSecurityLocksAreRepresented:", securityFilter);
+      for(RecordSecurityLock recordSecurityLock : RecordSecurityLockFilters.filterForReadLocks(CollectionUtils.nonNullList(instance.getTable(tableName).getRecordSecurityLocks())))
+      {
+         ensureRecordSecurityLockIsRepresented(instance, tableName, recordSecurityLock);
+      }
 
-      ////////////////////////////////////////////////////////////////////////////////////
-      // if there were any security filters built, then put those into the input filter //
-      ////////////////////////////////////////////////////////////////////////////////////
-      addSecurityFiltersToInputFilter(filter);
+      ensureFilterIsRepresented(filter);
+
+      addJoinsFromExposedJoinPaths();
+
+      /* todo!!
+      for(QueryJoin queryJoin : queryJoins)
+      {
+         QTableMetaData joinTable = instance.getTable(queryJoin.getJoinTable());
+         for(RecordSecurityLock recordSecurityLock : CollectionUtils.nonNullList(joinTable.getRecordSecurityLocks()))
+         {
+            // addCriteriaForRecordSecurityLock(instance, session, joinTable, securityCriteria, recordSecurityLock, joinsContext, queryJoin.getJoinTableOrItsAlias());
+         }
+      }
+      */
 
       log("Constructed JoinsContext", logPair("mainTableName", this.mainTableName), logPair("queryJoins", this.queryJoins.stream().map(qj -> qj.getJoinTable()).collect(Collectors.joining(","))));
-      log("", logPair("securityFilter", securityFilter));
-      log("", logPair("fullFilter", filter));
-      dumpDebug(false, true);
-      // log("--- END ------------------------------------------------------------------------");
+      log("--- END ------------------------------------------------------------------------");
    }
 
 
 
    /*******************************************************************************
-    ** Update the input filter with any security filters that were built.
-    *******************************************************************************/
-   private void addSecurityFiltersToInputFilter(QQueryFilter filter)
-   {
-      ////////////////////////////////////////////////////////////////////////////////////
-      // if there's no security filter criteria (including sub-filters), return w/ noop //
-      ////////////////////////////////////////////////////////////////////////////////////
-      if(CollectionUtils.nullSafeIsEmpty(securityFilter.getSubFilters()))
-      {
-         return;
-      }
-
-      ///////////////////////////////////////////////////////////////////////
-      // if the input filter is an OR we need to replace it with a new AND //
-      ///////////////////////////////////////////////////////////////////////
-      if(filter.getBooleanOperator().equals(QQueryFilter.BooleanOperator.OR))
-      {
-         List<QFilterCriteria> originalCriteria   = filter.getCriteria();
-         List<QQueryFilter>    originalSubFilters = filter.getSubFilters();
-
-         QQueryFilter replacementFilter = new QQueryFilter().withBooleanOperator(QQueryFilter.BooleanOperator.OR);
-         replacementFilter.setCriteria(originalCriteria);
-         replacementFilter.setSubFilters(originalSubFilters);
-
-         filter.setCriteria(new ArrayList<>());
-         filter.setSubFilters(new ArrayList<>());
-         filter.setBooleanOperator(QQueryFilter.BooleanOperator.AND);
-         filter.addSubFilter(replacementFilter);
-      }
-
-      filter.addSubFilter(securityFilter);
-   }
-
-
-
-   /*******************************************************************************
-    ** In case we've added any joins to the query that have security locks which
-    ** weren't previously added to the query, add them now.  basically, this is
-    ** calling ensureRecordSecurityLockIsRepresented for each queryJoin.
-    *******************************************************************************/
-   private void ensureAllJoinRecordSecurityLocksAreRepresented(QInstance instance) throws QException
-   {
-      /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-      // avoid concurrent modification exceptions by doing a double-loop and breaking the inner any time anything gets added //
-      /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-      Set<QueryJoin> processedQueryJoins   = new HashSet<>();
-      boolean        addedAnyThisIteration = true;
-      while(addedAnyThisIteration)
-      {
-         addedAnyThisIteration = false;
-
-         for(QueryJoin queryJoin : this.queryJoins)
-         {
-            boolean addedAnyForThisJoin = false;
-
-            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            // avoid double-processing the same query join                                                                                            //
-            // or adding security filters for a join who was only added to the query so that we could add locks (an ImplicitQueryJoinForSecurityLock) //
-            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            if(processedQueryJoins.contains(queryJoin) || queryJoin instanceof ImplicitQueryJoinForSecurityLock)
-            {
-               continue;
-            }
-            processedQueryJoins.add(queryJoin);
-
-            //////////////////////////////////////////////////////////////////////////////////////////
-            // process all locks on this join's join-table.  keep track if any new joins were added //
-            //////////////////////////////////////////////////////////////////////////////////////////
-            QTableMetaData joinTable = instance.getTable(queryJoin.getJoinTable());
-
-            MultiRecordSecurityLock multiRecordSecurityLock = RecordSecurityLockFilters.filterForReadLockTree(CollectionUtils.nonNullList(joinTable.getRecordSecurityLocks()));
-            for(RecordSecurityLock lock : multiRecordSecurityLock.getLocks())
-            {
-               List<QueryJoin> addedQueryJoins = ensureRecordSecurityLockIsRepresented(joinTable.getName(), queryJoin.getJoinTableOrItsAlias(), lock, queryJoin);
-
-               //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-               // if any joins were added by this call, add them to the set of processed ones, so they don't get re-processed. //
-               // also mark the flag that any were added for this join, to manage the double-looping                           //
-               //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-               if(CollectionUtils.nullSafeHasContents(addedQueryJoins))
-               {
-                  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-                  // make all new joins added in that method be of the same type (inner/left/etc) as the query join they are connected to //
-                  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-                  for(QueryJoin addedQueryJoin : addedQueryJoins)
-                  {
-                     addedQueryJoin.setType(queryJoin.getType());
-                  }
-
-                  processedQueryJoins.addAll(addedQueryJoins);
-                  addedAnyForThisJoin = true;
-               }
-            }
-
-            ///////////////////////////////////////////////////////////////////////////////////////////////
-            // if any new joins were added, we need to break the inner-loop, and continue the outer loop //
-            // e.g., to process the next query join (but we can't just go back to the foreach queryJoin, //
-            // because it would fail with concurrent modification)                                       //
-            ///////////////////////////////////////////////////////////////////////////////////////////////
-            if(addedAnyForThisJoin)
-            {
-               addedAnyThisIteration = true;
-               break;
-            }
-         }
-      }
-   }
-
-
-
-   /*******************************************************************************
-    ** For a given recordSecurityLock on a given table (with a possible alias),
-    ** make sure that if any joins are needed to get to the lock, that they are in the query.
     **
-    ** returns the list of query joins that were added, if any were added
     *******************************************************************************/
-   private List<QueryJoin> ensureRecordSecurityLockIsRepresented(String tableName, String tableNameOrAlias, RecordSecurityLock recordSecurityLock, QueryJoin sourceQueryJoin) throws QException
+   private void ensureRecordSecurityLockIsRepresented(QInstance instance, String tableName, RecordSecurityLock recordSecurityLock) throws QException
    {
-      List<QueryJoin> addedQueryJoins = new ArrayList<>();
-
-      ////////////////////////////////////////////////////////////////////////////
-      // if this lock is a multi-lock, then recursively process its child-locks //
-      ////////////////////////////////////////////////////////////////////////////
-      if(recordSecurityLock instanceof MultiRecordSecurityLock multiRecordSecurityLock)
-      {
-         log("Processing MultiRecordSecurityLock...");
-
-         /////////////////////////////////////////////////////////////////////////////////////////////////////////
-         // make a new level in the filter-tree - storing old cursor, and updating cursor to point at new level //
-         /////////////////////////////////////////////////////////////////////////////////////////////////////////
-         QQueryFilter oldSecurityFilterCursor = this.securityFilterCursor;
-         QQueryFilter nextLevelSecurityFilter = new QQueryFilter();
-         this.securityFilterCursor.addSubFilter(nextLevelSecurityFilter);
-         this.securityFilterCursor = nextLevelSecurityFilter;
-
-         ///////////////////////////////////////
-         // set the boolean operator to match //
-         ///////////////////////////////////////
-         nextLevelSecurityFilter.setBooleanOperator(multiRecordSecurityLock.getOperator().toFilterOperator());
-
-         //////////////////////
-         // process children //
-         //////////////////////
-         for(RecordSecurityLock childLock : CollectionUtils.nonNullList(multiRecordSecurityLock.getLocks()))
-         {
-            log(" - Recursive call for childLock: " + childLock);
-            addedQueryJoins.addAll(ensureRecordSecurityLockIsRepresented(tableName, tableNameOrAlias, childLock, sourceQueryJoin));
-         }
-
-         ////////////////////
-         // restore cursor //
-         ////////////////////
-         this.securityFilterCursor = oldSecurityFilterCursor;
-
-         return addedQueryJoins;
-      }
-
       ///////////////////////////////////////////////////////////////////////////////////////////////////
-      // A join name chain is going to look like this:                                                 //
-      // for a table:  orderLineItemExtrinsic (that's 2 away from order, where its security field is): //
+      // ok - so - the join name chain is going to be like this:                                       //
+      // for a table:  orderLineItemExtrinsic (that's 2 away from order, where the security field is): //
       // - securityFieldName = order.clientId                                                          //
       // - joinNameChain = orderJoinOrderLineItem, orderLineItemJoinOrderLineItemExtrinsic             //
       // so - to navigate from the table to the security field, we need to reverse the joinNameChain,  //
@@ -319,30 +129,30 @@ public class JoinsContext
       ///////////////////////////////////////////////////////////////////////////////////////////////////
       ArrayList<String> joinNameChain = new ArrayList<>(CollectionUtils.nonNullList(recordSecurityLock.getJoinNameChain()));
       Collections.reverse(joinNameChain);
-      log("Evaluating recordSecurityLock.  Join name chain is of length: " + joinNameChain.size(), logPair("tableNameOrAlias", tableNameOrAlias), logPair("recordSecurityLock", recordSecurityLock.getFieldName()), logPair("joinNameChain", joinNameChain));
+      log("Evaluating recordSecurityLock", logPair("recordSecurityLock", recordSecurityLock.getFieldName()), logPair("joinNameChain", joinNameChain));
 
-      QTableMetaData tmpTable                = instance.getTable(tableName);
-      String         securityFieldTableAlias = tableNameOrAlias;
-      String         baseTableOrAlias        = tableNameOrAlias;
-
-      boolean chainIsInner = true;
-      if(sourceQueryJoin != null && QueryJoin.Type.isOuter(sourceQueryJoin.getType()))
-      {
-         chainIsInner = false;
-      }
+      QTableMetaData tmpTable = instance.getTable(mainTableName);
 
       for(String joinName : joinNameChain)
       {
-         //////////////////////////////////////////////////////////////////////////////////////////////////
-         // check the joins currently in the query - if any are THIS join, then we don't need to add one //
-         //////////////////////////////////////////////////////////////////////////////////////////////////
-         List<QueryJoin> matchingQueryJoins = this.queryJoins.stream().filter(queryJoin ->
+         ///////////////////////////////////////////////////////////////////////////////////////////////////////
+         // check the joins currently in the query - if any are for this table, then we don't need to add one //
+         ///////////////////////////////////////////////////////////////////////////////////////////////////////
+         List<QueryJoin> matchingJoins = this.queryJoins.stream().filter(queryJoin ->
          {
-            QJoinMetaData joinMetaData = queryJoin.getJoinMetaData();
+            QJoinMetaData joinMetaData = null;
+            if(queryJoin.getJoinMetaData() != null)
+            {
+               joinMetaData = queryJoin.getJoinMetaData();
+            }
+            else
+            {
+               joinMetaData = findJoinMetaData(instance, tableName, queryJoin.getJoinTable());
+            }
             return (joinMetaData != null && Objects.equals(joinMetaData.getName(), joinName));
          }).toList();
 
-         if(CollectionUtils.nullSafeHasContents(matchingQueryJoins))
+         if(CollectionUtils.nullSafeHasContents(matchingJoins))
          {
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             // note - if a user added a join as an outer type, we need to change it to be inner, for the security purpose. //
@@ -350,40 +160,11 @@ public class JoinsContext
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             log("- skipping join already in the query", logPair("joinName", joinName));
 
-            QueryJoin matchedQueryJoin = matchingQueryJoins.get(0);
-
-            if(matchedQueryJoin.getType().equals(QueryJoin.Type.LEFT) || matchedQueryJoin.getType().equals(QueryJoin.Type.RIGHT))
-            {
-               chainIsInner = false;
-            }
-
-            /* ?? todo ??
-            if(matchedQueryJoin.getType().equals(QueryJoin.Type.LEFT) || matchedQueryJoin.getType().equals(QueryJoin.Type.RIGHT))
+            if(matchingJoins.get(0).getType().equals(QueryJoin.Type.LEFT) || matchingJoins.get(0).getType().equals(QueryJoin.Type.RIGHT))
             {
                log("- - although... it was here as an outer - so switching it to INNER", logPair("joinName", joinName));
-               matchedQueryJoin.setType(QueryJoin.Type.INNER);
+               matchingJoins.get(0).setType(QueryJoin.Type.INNER);
             }
-            */
-
-            //////////////////////////////////////////////////////////////////////////////////////////////////////
-            // as we're walking from tmpTable to the table which ultimately has the security key field,         //
-            // if the queryJoin we just found is joining out to tmpTable, then we need to advance tmpTable back //
-            // to the queryJoin's base table - else, tmpTable advances to the matched queryJoin's joinTable     //
-            //////////////////////////////////////////////////////////////////////////////////////////////////////
-            if(tmpTable.getName().equals(matchedQueryJoin.getJoinTable()))
-            {
-               securityFieldTableAlias = Objects.requireNonNullElse(matchedQueryJoin.getBaseTableOrAlias(), mainTableName);
-            }
-            else
-            {
-               securityFieldTableAlias = matchedQueryJoin.getJoinTableOrItsAlias();
-            }
-            tmpTable = instance.getTable(securityFieldTableAlias);
-
-            ////////////////////////////////////////////////////////////////////////////////////////
-            // set the baseTableOrAlias for the next iteration to be this join's joinTableOrAlias //
-            ////////////////////////////////////////////////////////////////////////////////////////
-            baseTableOrAlias = securityFieldTableAlias;
 
             continue;
          }
@@ -391,233 +172,20 @@ public class JoinsContext
          QJoinMetaData join = instance.getJoin(joinName);
          if(join.getLeftTable().equals(tmpTable.getName()))
          {
-            securityFieldTableAlias = join.getRightTable() + "_forSecurityJoin_" + join.getName();
-            QueryJoin queryJoin = new ImplicitQueryJoinForSecurityLock()
-               .withJoinMetaData(join)
-               .withType(chainIsInner ? QueryJoin.Type.INNER : QueryJoin.Type.LEFT)
-               .withBaseTableOrAlias(baseTableOrAlias)
-               .withAlias(securityFieldTableAlias);
-
-            if(securityFilterCursor.getBooleanOperator() == QQueryFilter.BooleanOperator.OR)
-            {
-               queryJoin.withType(QueryJoin.Type.LEFT);
-               chainIsInner = false;
-            }
-
-            addQueryJoin(queryJoin, "forRecordSecurityLock (non-flipped)", "- ");
-            addedQueryJoins.add(queryJoin);
+            QueryJoin queryJoin = new ImplicitQueryJoinForSecurityLock().withJoinMetaData(join).withType(QueryJoin.Type.INNER);
+            this.addQueryJoin(queryJoin, "forRecordSecurityLock (non-flipped)");
             tmpTable = instance.getTable(join.getRightTable());
          }
          else if(join.getRightTable().equals(tmpTable.getName()))
          {
-            securityFieldTableAlias = join.getLeftTable() + "_forSecurityJoin_" + join.getName();
-            QueryJoin queryJoin = new ImplicitQueryJoinForSecurityLock()
-               .withJoinMetaData(join.flip())
-               .withType(chainIsInner ? QueryJoin.Type.INNER : QueryJoin.Type.LEFT)
-               .withBaseTableOrAlias(baseTableOrAlias)
-               .withAlias(securityFieldTableAlias);
-
-            if(securityFilterCursor.getBooleanOperator() == QQueryFilter.BooleanOperator.OR)
-            {
-               queryJoin.withType(QueryJoin.Type.LEFT);
-               chainIsInner = false;
-            }
-
-            addQueryJoin(queryJoin, "forRecordSecurityLock (flipped)", "- ");
-            addedQueryJoins.add(queryJoin);
+            QueryJoin queryJoin = new ImplicitQueryJoinForSecurityLock().withJoinMetaData(join.flip()).withType(QueryJoin.Type.INNER);
+            this.addQueryJoin(queryJoin, "forRecordSecurityLock (flipped)");
             tmpTable = instance.getTable(join.getLeftTable());
          }
          else
          {
-            dumpDebug(false, true);
             throw (new QException("Error adding security lock joins to query - table name [" + tmpTable.getName() + "] not found in join [" + joinName + "]"));
          }
-
-         //////////////////////////////////////////////////////////////////////////////////////////////////////////////
-         // for the next iteration of the loop, set the next join's baseTableOrAlias to be the alias we just created //
-         //////////////////////////////////////////////////////////////////////////////////////////////////////////////
-         baseTableOrAlias = securityFieldTableAlias;
-      }
-
-      ////////////////////////////////////////////////////////////////////////////////////
-      // now that we know the joins/tables are in the query, add to the security filter //
-      ////////////////////////////////////////////////////////////////////////////////////
-      QueryJoin lastAddedQueryJoin = addedQueryJoins.isEmpty() ? null : addedQueryJoins.get(addedQueryJoins.size() - 1);
-      if(sourceQueryJoin != null && lastAddedQueryJoin == null)
-      {
-         lastAddedQueryJoin = sourceQueryJoin;
-      }
-      addSubFilterForRecordSecurityLock(recordSecurityLock, tmpTable, securityFieldTableAlias, !chainIsInner, lastAddedQueryJoin);
-
-      log("Finished evaluating recordSecurityLock");
-
-      return (addedQueryJoins);
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   private void addSubFilterForRecordSecurityLock(RecordSecurityLock recordSecurityLock, QTableMetaData table, String tableNameOrAlias, boolean isOuter, QueryJoin sourceQueryJoin)
-   {
-      QSession session = QContext.getQSession();
-
-      //////////////////////////////////////////////////////////////////////////////////////////////////////////////
-      // check if the key type has an all-access key, and if so, if it's set to true for the current user/session //
-      //////////////////////////////////////////////////////////////////////////////////////////////////////////////
-      QSecurityKeyType securityKeyType = instance.getSecurityKeyType(recordSecurityLock.getSecurityKeyType());
-      boolean haveAllAccessKey = false;
-      if(StringUtils.hasContent(securityKeyType.getAllAccessKeyName()))
-      {
-         //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-         // if we have all-access on this key, then we don't need a criterion for it (as long as we're in an AND filter) //
-         //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-         if(session.hasSecurityKeyValue(securityKeyType.getAllAccessKeyName(), true, QFieldType.BOOLEAN))
-         {
-            haveAllAccessKey = true;
-
-            if(sourceQueryJoin != null)
-            {
-               ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-               // in case the queryJoin object is re-used between queries, and its security criteria need to be different (!!), reset it //
-               // this can be exposed in tests - maybe not entirely expected in real-world, but seems safe enough                        //
-               ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-               sourceQueryJoin.withSecurityCriteria(new ArrayList<>());
-            }
-
-            ////////////////////////////////////////////////////////////////////////////////////////
-            // if we're in an AND filter, then we don't need a criteria for this lock, so return. //
-            ////////////////////////////////////////////////////////////////////////////////////////
-            boolean inAnAndFilter = securityFilterCursor.getBooleanOperator() == QQueryFilter.BooleanOperator.AND;
-            if(inAnAndFilter)
-            {
-               return;
-            }
-         }
-      }
-
-      /////////////////////////////////////////////////////////////////////////////////////////
-      // for locks w/o a join chain, the lock fieldName will simply be a field on the table. //
-      // so just prepend that with the tableNameOrAlias.                                     //
-      /////////////////////////////////////////////////////////////////////////////////////////
-      String fieldName = tableNameOrAlias + "." + recordSecurityLock.getFieldName();
-      if(CollectionUtils.nullSafeHasContents(recordSecurityLock.getJoinNameChain()))
-      {
-         /////////////////////////////////////////////////////////////////////////////////
-         // else, expect a "table.field" in the lock fieldName - but we want to replace //
-         // the table name part with a possible alias that we took in.                  //
-         /////////////////////////////////////////////////////////////////////////////////
-         String[] parts = recordSecurityLock.getFieldName().split("\\.");
-         if(parts.length != 2)
-         {
-            dumpDebug(false, true);
-            throw new IllegalArgumentException("Mal-formatted recordSecurityLock fieldName for lock with joinNameChain in query: " + fieldName);
-         }
-         fieldName = tableNameOrAlias + "." + parts[1];
-      }
-
-      ///////////////////////////////////////////////////////////////////////////////////////////
-      // else - get the key values from the session and decide what kind of criterion to build //
-      ///////////////////////////////////////////////////////////////////////////////////////////
-      QQueryFilter          lockFilter   = new QQueryFilter();
-      List<QFilterCriteria> lockCriteria = new ArrayList<>();
-      lockFilter.setCriteria(lockCriteria);
-
-      QFieldType type = QFieldType.INTEGER;
-      try
-      {
-         JoinsContext.FieldAndTableNameOrAlias fieldAndTableNameOrAlias = getFieldAndTableNameOrAlias(fieldName);
-         type = fieldAndTableNameOrAlias.field().getType();
-      }
-      catch(Exception e)
-      {
-         LOG.debug("Error getting field type...  Trying Integer", e);
-      }
-
-      if(haveAllAccessKey)
-      {
-         ////////////////////////////////////////////////////////////////////////////////////////////
-         // if we have an all access key (but we got here because we're part of an OR query), then //
-         // write a criterion that will always be true - e.g., field=field                         //
-         ////////////////////////////////////////////////////////////////////////////////////////////
-         lockCriteria.add(new QFilterCriteria(fieldName, QCriteriaOperator.TRUE));
-      }
-      else
-      {
-         List<Serializable> securityKeyValues = session.getSecurityKeyValues(recordSecurityLock.getSecurityKeyType(), type);
-         if(CollectionUtils.nullSafeIsEmpty(securityKeyValues))
-         {
-            ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            // handle user with no values -- they can only see null values, and only iff the lock's null-value behavior is ALLOW //
-            ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            if(RecordSecurityLock.NullValueBehavior.ALLOW.equals(NullValueBehaviorUtil.getEffectiveNullValueBehavior(recordSecurityLock)))
-            {
-               lockCriteria.add(new QFilterCriteria(fieldName, QCriteriaOperator.IS_BLANK));
-            }
-            else
-            {
-               ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-               // else, if no user/session values, and null-value behavior is deny, then setup a FALSE condition, to allow no rows.         //
-               // todo - maybe avoid running the whole query - as you're not allowed ANY records (based on boolean tree down to this point) //
-               ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-               lockCriteria.add(new QFilterCriteria(fieldName, QCriteriaOperator.FALSE));
-            }
-         }
-         else
-         {
-            //////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            // else, if user/session has some values, build an IN rule -                                                //
-            // noting that if the lock's null-value behavior is ALLOW, then we actually want IS_NULL_OR_IN, not just IN //
-            //////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            if(RecordSecurityLock.NullValueBehavior.ALLOW.equals(NullValueBehaviorUtil.getEffectiveNullValueBehavior(recordSecurityLock)))
-            {
-               lockCriteria.add(new QFilterCriteria(fieldName, QCriteriaOperator.IS_NULL_OR_IN, securityKeyValues));
-            }
-            else
-            {
-               lockCriteria.add(new QFilterCriteria(fieldName, QCriteriaOperator.IN, securityKeyValues));
-            }
-         }
-      }
-
-      ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-      // if there's a sourceQueryJoin, then set the lockCriteria on that join - so it gets written into the JOIN ... ON clause //
-      // ... unless we're writing an OR filter.  then we need the condition in the WHERE clause                                //
-      ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-      boolean doNotPutCriteriaInJoinOn = securityFilterCursor.getBooleanOperator() == QQueryFilter.BooleanOperator.OR;
-      if(sourceQueryJoin != null && !doNotPutCriteriaInJoinOn)
-      {
-         sourceQueryJoin.withSecurityCriteria(lockCriteria);
-      }
-      else
-      {
-         ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-         // we used to add an OR IS NULL for cases of an outer-join - but instead, this is now handled by putting the lockCriteria //
-         // into the join (see above) - so this check is probably deprecated.                                                      //
-         ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-         /*
-            ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            // if this field is on the outer side of an outer join, then if we do a straight filter on it, then we're basically      //
-            // nullifying the outer join... so for an outer join use-case, OR the security field criteria with a primary-key IS NULL //
-            // which will make missing rows from the join be found.                                                                  //
-            ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            if(isOuter)
-            {
-               if(table == null)
-               {
-                  table = QContext.getQInstance().getTable(aliasToTableNameMap.get(tableNameOrAlias));
-               }
-
-               lockFilter.setBooleanOperator(QQueryFilter.BooleanOperator.OR);
-               lockFilter.addCriteria(new QFilterCriteria(tableNameOrAlias + "." + table.getPrimaryKeyField(), QCriteriaOperator.IS_BLANK));
-            }
-         */
-
-         /////////////////////////////////////////////////////////////////////////////////////////////////////
-         // If this filter isn't for a queryJoin, then just add it to the main list of security sub-filters //
-         /////////////////////////////////////////////////////////////////////////////////////////////////////
-         this.securityFilterCursor.addSubFilter(lockFilter);
       }
    }
 
@@ -629,9 +197,9 @@ public class JoinsContext
     ** use this method to add to the list, instead of ever adding directly, as it's
     ** important do to that process step (and we've had bugs when it wasn't done).
     *******************************************************************************/
-   private void addQueryJoin(QueryJoin queryJoin, String reason, String logPrefix) throws QException
+   private void addQueryJoin(QueryJoin queryJoin, String reason) throws QException
    {
-      log(Objects.requireNonNullElse(logPrefix, "") + "Adding query join to context",
+      log("Adding query join to context",
          logPair("reason", reason),
          logPair("joinTable", queryJoin.getJoinTable()),
          logPair("joinMetaData.name", () -> queryJoin.getJoinMetaData().getName()),
@@ -640,46 +208,34 @@ public class JoinsContext
       );
       this.queryJoins.add(queryJoin);
       processQueryJoin(queryJoin);
-      dumpDebug(false, false);
    }
 
 
 
    /*******************************************************************************
     ** If there are any joins in the context that don't have a join meta data, see
-    ** if we can find the JoinMetaData to use for them by looking at all joins in the
-    ** instance, or at the main table's exposed joins, and using their join paths.
+    ** if we can find the JoinMetaData to use for them by looking at the main table's
+    ** exposed joins, and using their join paths.
     *******************************************************************************/
-   private void fillInMissingJoinMetaData() throws QException
+   private void addJoinsFromExposedJoinPaths() throws QException
    {
-      log("Begin adding missing join meta data");
-
       ////////////////////////////////////////////////////////////////////////////////
       // do a double-loop, to avoid concurrent modification on the queryJoins list. //
       // that is to say, we'll loop over that list, but possibly add things to it,  //
       // in which case we'll set this flag, and break the inner loop, to go again.  //
       ////////////////////////////////////////////////////////////////////////////////
-      Set<QueryJoin> processedQueryJoins = new HashSet<>();
-      boolean        addedJoin;
+      boolean addedJoin;
       do
       {
          addedJoin = false;
          for(QueryJoin queryJoin : queryJoins)
          {
-            if(processedQueryJoins.contains(queryJoin))
-            {
-               continue;
-            }
-            processedQueryJoins.add(queryJoin);
-
             ///////////////////////////////////////////////////////////////////////////////////////////////
             // if the join has joinMetaData, then we don't need to process it... unless it needs flipped //
             ///////////////////////////////////////////////////////////////////////////////////////////////
             QJoinMetaData joinMetaData = queryJoin.getJoinMetaData();
             if(joinMetaData != null)
             {
-               log("- QueryJoin already has joinMetaData", logPair("joinMetaDataName", joinMetaData.getName()));
-
                boolean isJoinLeftTableInQuery = false;
                String  joinMetaDataLeftTable  = joinMetaData.getLeftTable();
                if(joinMetaDataLeftTable.equals(mainTableName))
@@ -709,7 +265,7 @@ public class JoinsContext
                /////////////////////////////////////////////////////////////////////////////////
                if(!isJoinLeftTableInQuery)
                {
-                  log("- - Flipping queryJoin because its leftTable wasn't found in the query", logPair("joinMetaDataName", joinMetaData.getName()), logPair("leftTable", joinMetaDataLeftTable));
+                  log("Flipping queryJoin because its leftTable wasn't found in the query", logPair("joinMetaDataName", joinMetaData.getName()), logPair("leftTable", joinMetaDataLeftTable));
                   queryJoin.setJoinMetaData(joinMetaData.flip());
                }
             }
@@ -719,13 +275,11 @@ public class JoinsContext
                // try to find a direct join between the main table and this table. //
                // if one is found, then put it (the meta data) on the query join.  //
                //////////////////////////////////////////////////////////////////////
-               log("- QueryJoin doesn't have metaData - looking for it", logPair("joinTableOrItsAlias", queryJoin.getJoinTableOrItsAlias()));
-
                String        baseTableName = Objects.requireNonNullElse(resolveTableNameOrAliasToTableName(queryJoin.getBaseTableOrAlias()), mainTableName);
-               QJoinMetaData found         = findJoinMetaData(baseTableName, queryJoin.getJoinTable(), true);
+               QJoinMetaData found         = findJoinMetaData(instance, baseTableName, queryJoin.getJoinTable());
                if(found != null)
                {
-                  log("- - Found joinMetaData - setting it in queryJoin", logPair("joinMetaDataName", found.getName()), logPair("baseTableName", baseTableName), logPair("joinTable", queryJoin.getJoinTable()));
+                  log("Found joinMetaData - setting it in queryJoin", logPair("joinMetaDataName", found.getName()), logPair("baseTableName", baseTableName), logPair("joinTable", queryJoin.getJoinTable()));
                   queryJoin.setJoinMetaData(found);
                }
                else
@@ -739,7 +293,7 @@ public class JoinsContext
                   {
                      if(queryJoin.getJoinTable().equals(exposedJoin.getJoinTable()))
                      {
-                        log("- - Found an exposed join", logPair("mainTable", mainTableName), logPair("joinTable", queryJoin.getJoinTable()), logPair("joinPath", exposedJoin.getJoinPath()));
+                        log("Found an exposed join", logPair("mainTable", mainTableName), logPair("joinTable", queryJoin.getJoinTable()), logPair("joinPath", exposedJoin.getJoinPath()));
 
                         /////////////////////////////////////////////////////////////////////////////////////
                         // loop backward through the join path (from the joinTable back to the main table) //
@@ -750,7 +304,6 @@ public class JoinsContext
                         {
                            String        joinName  = exposedJoin.getJoinPath().get(i);
                            QJoinMetaData joinToAdd = instance.getJoin(joinName);
-                           log("- - - evaluating joinPath element", logPair("i", i), logPair("joinName", joinName));
 
                            /////////////////////////////////////////////////////////////////////////////
                            // get the name from the opposite side of the join (flipping it if needed) //
@@ -779,22 +332,15 @@ public class JoinsContext
                                     queryJoin.setBaseTableOrAlias(nextTable);
                                  }
                                  queryJoin.setJoinMetaData(joinToAdd);
-                                 log("- - - - this is the last element in the join path, so setting this joinMetaData on the original queryJoin");
                               }
                               else
                               {
                                  QueryJoin queryJoinToAdd = makeQueryJoinFromJoinAndTableNames(nextTable, tmpTable, joinToAdd);
                                  queryJoinToAdd.setType(queryJoin.getType());
                                  addedAnyQueryJoins = true;
-                                 log("- - - - this is not the last element in the join path, so adding a new query join:");
-                                 addQueryJoin(queryJoinToAdd, "forExposedJoin", "- - - - - - ");
-                                 dumpDebug(false, false);
+                                 this.addQueryJoin(queryJoinToAdd, "forExposedJoin");
                               }
                            }
-                           else
-                           {
-                              log("- - - - join doesn't need added to the query");
-                           }
 
                            tmpTable = nextTable;
                         }
@@ -815,7 +361,6 @@ public class JoinsContext
       }
       while(addedJoin);
 
-      log("Done adding missing join meta data");
    }
 
 
@@ -825,12 +370,12 @@ public class JoinsContext
     *******************************************************************************/
    private boolean doesJoinNeedAddedToQuery(String joinName)
    {
-      ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-      // look at all queryJoins already in context - if any have this join's name, and aren't implicit-security joins, then we don't need this join... //
-      ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // look at all queryJoins already in context - if any have this join's name, then we don't need this join... //
+      ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
       for(QueryJoin queryJoin : queryJoins)
       {
-         if(queryJoin.getJoinMetaData() != null && queryJoin.getJoinMetaData().getName().equals(joinName) && !(queryJoin instanceof ImplicitQueryJoinForSecurityLock))
+         if(queryJoin.getJoinMetaData() != null && queryJoin.getJoinMetaData().getName().equals(joinName))
          {
             return (false);
          }
@@ -850,7 +395,6 @@ public class JoinsContext
       String         tableNameOrAlias = queryJoin.getJoinTableOrItsAlias();
       if(aliasToTableNameMap.containsKey(tableNameOrAlias))
       {
-         dumpDebug(false, true);
          throw (new QException("Duplicate table name or alias: " + tableNameOrAlias));
       }
       aliasToTableNameMap.put(tableNameOrAlias, joinTable.getName());
@@ -895,7 +439,6 @@ public class JoinsContext
          String[] parts = fieldName.split("\\.");
          if(parts.length != 2)
          {
-            dumpDebug(false, true);
             throw new IllegalArgumentException("Mal-formatted field name in query: " + fieldName);
          }
 
@@ -906,7 +449,6 @@ public class JoinsContext
          QTableMetaData table = instance.getTable(tableName);
          if(table == null)
          {
-            dumpDebug(false, true);
             throw new IllegalArgumentException("Could not find table [" + tableName + "] in instance for query");
          }
          return new FieldAndTableNameOrAlias(table.getField(baseFieldName), tableOrAlias);
@@ -961,17 +503,17 @@ public class JoinsContext
 
       for(String filterTable : filterTables)
       {
-         log("Evaluating filter", logPair("filterTable", filterTable));
+         log("Evaluating filterTable", logPair("filterTable", filterTable));
          if(!aliasToTableNameMap.containsKey(filterTable) && !Objects.equals(mainTableName, filterTable))
          {
-            log("- table not in query - adding a join for it", logPair("filterTable", filterTable));
+            log("- table not in query - adding it", logPair("filterTable", filterTable));
             boolean found = false;
             for(QJoinMetaData join : CollectionUtils.nonNullMap(QContext.getQInstance().getJoins()).values())
             {
                QueryJoin queryJoin = makeQueryJoinFromJoinAndTableNames(mainTableName, filterTable, join);
                if(queryJoin != null)
                {
-                  addQueryJoin(queryJoin, "forFilter (join found in instance)", "- - ");
+                  this.addQueryJoin(queryJoin, "forFilter (join found in instance)");
                   found = true;
                   break;
                }
@@ -980,13 +522,9 @@ public class JoinsContext
             if(!found)
             {
                QueryJoin queryJoin = new QueryJoin().withJoinTable(filterTable).withType(QueryJoin.Type.INNER);
-               addQueryJoin(queryJoin, "forFilter (join not found in instance)", "- - ");
+               this.addQueryJoin(queryJoin, "forFilter (join not found in instance)");
             }
          }
-         else
-         {
-            log("- table is already in query - not adding any joins", logPair("filterTable", filterTable));
-         }
       }
    }
 
@@ -1028,11 +566,6 @@ public class JoinsContext
             getTableNameFromFieldNameAndAddToSet(criteria.getOtherFieldName(), filterTables);
          }
 
-         for(QFilterOrderBy orderBy : CollectionUtils.nonNullList(filter.getOrderBys()))
-         {
-            getTableNameFromFieldNameAndAddToSet(orderBy.getFieldName(), filterTables);
-         }
-
          for(QQueryFilter subFilter : CollectionUtils.nonNullList(filter.getSubFilters()))
          {
             populateFilterTablesSet(subFilter, filterTables);
@@ -1059,7 +592,7 @@ public class JoinsContext
    /*******************************************************************************
     **
     *******************************************************************************/
-   public QJoinMetaData findJoinMetaData(String baseTableName, String joinTableName, boolean useExposedJoins)
+   public QJoinMetaData findJoinMetaData(QInstance instance, String baseTableName, String joinTableName)
    {
       List<QJoinMetaData> matches = new ArrayList<>();
       if(baseTableName != null)
@@ -1111,29 +644,7 @@ public class JoinsContext
       }
       else if(matches.size() > 1)
       {
-         ////////////////////////////////////////////////////////////////////////////////
-         // if we found more than one join, but we're allowed to useExposedJoins, then //
-         // see if we can tell which match to used based on the table's exposed joins  //
-         ////////////////////////////////////////////////////////////////////////////////
-         if(useExposedJoins)
-         {
-            QTableMetaData mainTable = QContext.getQInstance().getTable(mainTableName);
-            for(ExposedJoin exposedJoin : mainTable.getExposedJoins())
-            {
-               if(exposedJoin.getJoinTable().equals(joinTableName))
-               {
-                  // todo ... is it wrong to always use 0??
-                  return instance.getJoin(exposedJoin.getJoinPath().get(0));
-               }
-            }
-         }
-
-         ///////////////////////////////////////////////
-         // if we couldn't figure it out, then throw. //
-         ///////////////////////////////////////////////
-         dumpDebug(false, true);
-         throw (new RuntimeException("More than 1 join was found between [" + baseTableName + "] and [" + joinTableName + "] "
-            + (useExposedJoins ? "(and exposed joins didn't clarify which one to use). " : "") + "Specify which one in your QueryJoin."));
+         throw (new RuntimeException("More than 1 join was found between [" + baseTableName + "] and [" + joinTableName + "].  Specify which one in your QueryJoin."));
       }
 
       return (null);
@@ -1158,79 +669,4 @@ public class JoinsContext
       LOG.log(logLevel, message, null, logPairs);
    }
 
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   private void logFilter(String message, QQueryFilter filter)
-   {
-      if(logLevelForFilter.equals(Level.OFF))
-      {
-         return;
-      }
-      System.out.println(message + "\n" + filter);
-   }
-
-
-
-   /*******************************************************************************
-    ** Print (to stdout, for easier reading) the object in a big table format for
-    ** debugging.  Happens any time logLevel is > OFF.  Not meant for loggly.
-    *******************************************************************************/
-   private void dumpDebug(boolean isStart, boolean isEnd)
-   {
-      if(logLevel.equals(Level.OFF))
-      {
-         return;
-      }
-
-      int sm       = 8;
-      int md       = 30;
-      int lg       = 50;
-      int overhead = 14;
-      int full     = sm + 3 * md + lg + overhead;
-
-      if(isStart)
-      {
-         System.out.println("\n" + StringUtils.safeTruncate("--- Start [main table: " + this.mainTableName + "] " + "-".repeat(full), full));
-      }
-
-      StringBuilder rs           = new StringBuilder();
-      String        formatString = "| %-" + md + "s | %-" + md + "s %-" + md + "s | %-" + lg + "s | %-" + sm + "s |\n";
-      rs.append(String.format(formatString, "Base Table", "Join Table", "(Alias)", "Join Meta Data", "Type"));
-      String dashesLg = "-".repeat(lg);
-      String dashesMd = "-".repeat(md);
-      String dashesSm = "-".repeat(sm);
-      rs.append(String.format(formatString, dashesMd, dashesMd, dashesMd, dashesLg, dashesSm));
-      if(CollectionUtils.nullSafeHasContents(queryJoins))
-      {
-         for(QueryJoin queryJoin : queryJoins)
-         {
-            rs.append(String.format(
-               formatString,
-               StringUtils.hasContent(queryJoin.getBaseTableOrAlias()) ? StringUtils.safeTruncate(queryJoin.getBaseTableOrAlias(), md) : "--",
-               StringUtils.safeTruncate(queryJoin.getJoinTable(), md),
-               (StringUtils.hasContent(queryJoin.getAlias()) ? "(" + StringUtils.safeTruncate(queryJoin.getAlias(), md - 2) + ")" : ""),
-               queryJoin.getJoinMetaData() == null ? "--" : StringUtils.safeTruncate(queryJoin.getJoinMetaData().getName(), lg),
-               queryJoin.getType()));
-         }
-      }
-      else
-      {
-         rs.append(String.format(formatString, "-empty-", "", "", "", ""));
-      }
-
-      System.out.print(rs);
-
-      System.out.println(securityFilter);
-
-      if(isEnd)
-      {
-         System.out.println(StringUtils.safeTruncate("--- End " + "-".repeat(full), full) + "\n");
-      }
-      else
-      {
-         System.out.println(StringUtils.safeTruncate("-".repeat(full), full));
-      }
-   }
 }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/actions/tables/query/QCriteriaOperator.java

@@ -49,7 +49,5 @@ public enum QCriteriaOperator
    IS_BLANK,
    IS_NOT_BLANK,
    BETWEEN,
-   NOT_BETWEEN,
-   TRUE,
-   FALSE
+   NOT_BETWEEN
 }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/actions/tables/query/QFilterCriteria.java

@@ -306,11 +306,6 @@ public class QFilterCriteria implements Serializable, Cloneable
    @Override
    public String toString()
    {
-      if(fieldName == null)
-      {
-         return ("<null-field-criteria>");
-      }
-
       StringBuilder rs = new StringBuilder(fieldName);
       try
       {

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/actions/tables/query/QQueryFilter.java

@@ -25,18 +25,13 @@ package com.kingsrook.qqq.backend.core.model.actions.tables.query;
 import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
-import com.kingsrook.qqq.backend.core.exceptions.QException;
-import com.kingsrook.qqq.backend.core.exceptions.QUserFacingException;
 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.query.expressions.AbstractFilterExpression;
-import com.kingsrook.qqq.backend.core.model.actions.tables.query.expressions.FilterVariableExpression;
 import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
-import com.kingsrook.qqq.backend.core.utils.StringUtils;
 import com.kingsrook.qqq.backend.core.utils.ValueUtils;
 
 
@@ -143,7 +138,7 @@ public class QQueryFilter implements Serializable, Cloneable
 
 
    /*******************************************************************************
-    ** recursively look at both this filter, and any sub-filters it may have.
+    **
     *******************************************************************************/
    public boolean hasAnyCriteria()
    {
@@ -156,7 +151,7 @@ public class QQueryFilter implements Serializable, Cloneable
       {
          for(QQueryFilter subFilter : subFilters)
          {
-            if(subFilter != null && subFilter.hasAnyCriteria())
+            if(subFilter.hasAnyCriteria())
             {
                return (true);
             }
@@ -366,44 +361,23 @@ public class QQueryFilter implements Serializable, Cloneable
       StringBuilder rs = new StringBuilder("(");
       try
       {
-         int criteriaIndex = 0;
          for(QFilterCriteria criterion : CollectionUtils.nonNullList(criteria))
          {
-            if(criteriaIndex > 0)
-            {
-               rs.append(" ").append(getBooleanOperator()).append(" ");
-            }
-            rs.append(criterion);
-            criteriaIndex++;
+            rs.append(criterion).append(" ").append(getBooleanOperator()).append(" ");
          }
 
-         if(CollectionUtils.nullSafeHasContents(subFilters))
+         for(QQueryFilter subFilter : CollectionUtils.nonNullList(subFilters))
          {
-            rs.append("Sub:{");
-            int subIndex = 0;
-            for(QQueryFilter subFilter : CollectionUtils.nonNullList(subFilters))
-            {
-               if(subIndex > 0)
-               {
-                  rs.append(" ").append(getBooleanOperator()).append(" ");
-               }
-               rs.append(subFilter);
-               subIndex++;
-            }
-            rs.append("}");
+            rs.append(subFilter);
          }
-
          rs.append(")");
 
-         if(CollectionUtils.nullSafeHasContents(orderBys))
+         rs.append("OrderBy[");
+         for(QFilterOrderBy orderBy : CollectionUtils.nonNullList(orderBys))
          {
-            rs.append("OrderBy[");
-            for(QFilterOrderBy orderBy : CollectionUtils.nonNullList(orderBys))
-            {
-               rs.append(orderBy).append(",");
-            }
-            rs.append("]");
+            rs.append(orderBy).append(",");
          }
+         rs.append("]");
       }
       catch(Exception e)
       {
@@ -416,88 +390,6 @@ public class QQueryFilter implements Serializable, Cloneable
 
 
 
-   /*******************************************************************************
-    ** Replaces any FilterVariables' variableNames with one constructed from the field
-    ** name, criteria, and index, camel style
-    **
-    *******************************************************************************/
-   public void prepForBackend()
-   {
-      Map<String, Integer> fieldOperatorMap = new HashMap<>();
-      for(QFilterCriteria criterion : getCriteria())
-      {
-         if(criterion.getValues() != null)
-         {
-            int criteriaIndex = 1;
-            int valueIndex    = 0;
-            for(Serializable value : criterion.getValues())
-            {
-               ///////////////////////////////////////////////////////////////////////////////
-               // keep track of what the index is for this criterion, this way if there are //
-               // more than one with the same id/operator values, we can differentiate      //
-               ///////////////////////////////////////////////////////////////////////////////
-               String backendName = getBackendName(criterion, valueIndex);
-               if(!fieldOperatorMap.containsKey(backendName))
-               {
-                  fieldOperatorMap.put(backendName, criteriaIndex);
-               }
-               else
-               {
-                  criteriaIndex = fieldOperatorMap.get(backendName) + 1;
-                  fieldOperatorMap.put(backendName, criteriaIndex);
-               }
-
-               if(value instanceof FilterVariableExpression fve)
-               {
-                  if(criteriaIndex > 1)
-                  {
-                     backendName += criteriaIndex;
-                  }
-                  fve.setVariableName(backendName);
-               }
-
-               valueIndex++;
-            }
-         }
-      }
-   }
-
-
-
-   /*******************************************************************************
-    ** builds up a backend name for a field variable expression
-    **
-    *******************************************************************************/
-   private String getBackendName(QFilterCriteria criterion, int valueIndex)
-   {
-      StringBuilder backendName = new StringBuilder();
-      for(String fieldNameParts : criterion.getFieldName().split("\\."))
-      {
-         backendName.append(StringUtils.ucFirst(fieldNameParts));
-      }
-
-      for(String operatorParts : criterion.getOperator().name().split("_"))
-      {
-         backendName.append(StringUtils.ucFirst(operatorParts.toLowerCase()));
-      }
-
-      if(criterion.getOperator().equals(QCriteriaOperator.BETWEEN) || criterion.getOperator().equals(QCriteriaOperator.NOT_BETWEEN))
-      {
-         if(valueIndex == 0)
-         {
-            backendName.append("From");
-         }
-         else
-         {
-            backendName.append("To");
-         }
-      }
-
-      return (StringUtils.lcFirst(backendName.toString()));
-   }
-
-
-
    /*******************************************************************************
     ** Replace any criteria values that look like ${input.XXX} with the value of XXX
     ** from the supplied inputValues map.
@@ -506,10 +398,8 @@ public class QQueryFilter implements Serializable, Cloneable
     ** QQueryFilter - e.g., if it's one that defined in metaData, and that we don't
     ** want to be (permanently) changed!!
     *******************************************************************************/
-   public void interpretValues(Map<String, Serializable> inputValues) throws QException
+   public void interpretValues(Map<String, Serializable> inputValues)
    {
-      List<Exception> caughtExceptions = new ArrayList<>();
-
       QMetaDataVariableInterpreter variableInterpreter = new QMetaDataVariableInterpreter();
       variableInterpreter.addValueMap("input", inputValues);
       for(QFilterCriteria criterion : getCriteria())
@@ -520,45 +410,24 @@ public class QQueryFilter implements Serializable, Cloneable
 
             for(Serializable value : criterion.getValues())
             {
-               try
+               if(value instanceof AbstractFilterExpression<?>)
                {
-                  if(value instanceof AbstractFilterExpression<?>)
-                  {
-                     ///////////////////////////////////////////////////////////////////////
-                     // if a filter variable expression, evaluate the input values, which //
-                     // will replace the variables with the corresponding actual values   //
-                     ///////////////////////////////////////////////////////////////////////
-                     if(value instanceof FilterVariableExpression filterVariableExpression)
-                     {
-                        newValues.add(filterVariableExpression.evaluateInputValues(inputValues));
-                     }
-                     else
-                     {
-                        newValues.add(value);
-                     }
-                  }
-                  else
-                  {
-                     String       valueAsString    = ValueUtils.getValueAsString(value);
-                     Serializable interpretedValue = variableInterpreter.interpretForObject(valueAsString);
-                     newValues.add(interpretedValue);
-                  }
+                  /////////////////////////////////////////////////////////////////////////
+                  // todo - do we want to try to interpret values within the expression? //
+                  // e.g., greater than now minus ${input.noOfDays}                      //
+                  /////////////////////////////////////////////////////////////////////////
+                  newValues.add(value);
                }
-               catch(Exception e)
+               else
                {
-                  caughtExceptions.add(e);
+                  String       valueAsString    = ValueUtils.getValueAsString(value);
+                  Serializable interpretedValue = variableInterpreter.interpretForObject(valueAsString);
+                  newValues.add(interpretedValue);
                }
             }
             criterion.setValues(newValues);
          }
       }
-
-      if(!caughtExceptions.isEmpty())
-      {
-         String  message       = "Error interpreting filter values: " + StringUtils.joinWithCommasAndAnd(caughtExceptions.stream().map(e -> e.getMessage()).toList());
-         boolean allUserFacing = caughtExceptions.stream().allMatch(QUserFacingException.class::isInstance);
-         throw (allUserFacing ? new QUserFacingException(message) : new QException(message));
-      }
    }
 
 

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/actions/tables/query/QueryInput.java

@@ -25,7 +25,6 @@ package com.kingsrook.qqq.backend.core.model.actions.tables.query;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.EnumSet;
-import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 import com.kingsrook.qqq.backend.core.actions.QBackendTransaction;
@@ -38,7 +37,7 @@ import com.kingsrook.qqq.backend.core.model.actions.tables.QueryOrGetInputInterf
  ** Input data for the Query action
  **
  *******************************************************************************/
-public class QueryInput extends AbstractTableActionInput implements QueryOrGetInputInterface, Cloneable
+public class QueryInput extends AbstractTableActionInput implements QueryOrGetInputInterface
 {
    private QBackendTransaction transaction;
    private QQueryFilter        filter;
@@ -110,40 +109,6 @@ public class QueryInput extends AbstractTableActionInput implements QueryOrGetIn
 
 
 
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   @Override
-   public QueryInput clone() throws CloneNotSupportedException
-   {
-      QueryInput clone = (QueryInput) super.clone();
-
-      if(fieldsToTranslatePossibleValues != null)
-      {
-         clone.fieldsToTranslatePossibleValues = new HashSet<>(fieldsToTranslatePossibleValues);
-      }
-
-      if(queryJoins != null)
-      {
-         clone.queryJoins = new ArrayList<>(queryJoins);
-      }
-
-      if(clone.associationNamesToInclude != null)
-      {
-         clone.associationNamesToInclude = new HashSet<>(associationNamesToInclude);
-      }
-
-      if(queryHints != null)
-      {
-         clone.queryHints = EnumSet.noneOf(QueryHint.class);
-         clone.queryHints.addAll(queryHints);
-      }
-
-      return (clone);
-   }
-
-
-
    /*******************************************************************************
     ** Getter for filter
     **

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/actions/tables/query/QueryJoin.java

@@ -22,8 +22,6 @@
 package com.kingsrook.qqq.backend.core.model.actions.tables.query;
 
 
-import java.util.ArrayList;
-import java.util.List;
 import java.util.Objects;
 import com.kingsrook.qqq.backend.core.model.metadata.joins.QJoinMetaData;
 import com.kingsrook.qqq.backend.core.utils.StringUtils;
@@ -51,10 +49,6 @@ import com.kingsrook.qqq.backend.core.utils.StringUtils;
  ** specific joinMetaData to use must be set.  The joinMetaData field can also be
  ** used instead of specify joinTable and baseTableOrAlias, but only for cases
  ** where the baseTable is not an alias.
- **
- ** The securityCriteria member, in general, is meant to be populated when a
- ** JoinsContext is constructed before executing a query, and not meant to be set
- ** by users.
  *******************************************************************************/
 public class QueryJoin
 {
@@ -65,30 +59,13 @@ public class QueryJoin
    private boolean       select = false;
    private Type          type   = Type.INNER;
 
-   private List<QFilterCriteria> securityCriteria = new ArrayList<>();
-
 
 
    /*******************************************************************************
-    ** define the types of joins - INNER, LEFT, RIGHT, or FULL.
+    **
     *******************************************************************************/
    public enum Type
-   {
-      INNER,
-      LEFT,
-      RIGHT,
-      FULL;
-
-
-
-      /*******************************************************************************
-       ** check if a join is an OUTER type (LEFT or RIGHT).
-       *******************************************************************************/
-      public static boolean isOuter(Type type)
-      {
-         return (LEFT == type || RIGHT == type);
-      }
-   }
+   {INNER, LEFT, RIGHT, FULL}
 
 
 
@@ -371,66 +348,4 @@ public class QueryJoin
       return (this);
    }
 
-
-
-   /*******************************************************************************
-    ** Getter for securityCriteria
-    *******************************************************************************/
-   public List<QFilterCriteria> getSecurityCriteria()
-   {
-      return (this.securityCriteria);
-   }
-
-
-
-   /*******************************************************************************
-    ** Setter for securityCriteria
-    *******************************************************************************/
-   public void setSecurityCriteria(List<QFilterCriteria> securityCriteria)
-   {
-      this.securityCriteria = securityCriteria;
-   }
-
-
-
-   /*******************************************************************************
-    ** Fluent setter for securityCriteria
-    *******************************************************************************/
-   public QueryJoin withSecurityCriteria(List<QFilterCriteria> securityCriteria)
-   {
-      this.securityCriteria = securityCriteria;
-      return (this);
-   }
-
-
-
-   /*******************************************************************************
-    ** Fluent setter for securityCriteria
-    *******************************************************************************/
-   public QueryJoin withSecurityCriteria(QFilterCriteria securityCriteria)
-   {
-      if(this.securityCriteria == null)
-      {
-         this.securityCriteria = new ArrayList<>();
-      }
-      this.securityCriteria.add(securityCriteria);
-      return (this);
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   @Override
-   public String toString()
-   {
-      return "QueryJoin{base="
-         + baseTableOrAlias + ", joinTable='"
-         + joinTable + ", joinMetaData="
-         + (joinMetaData == null ? null : joinMetaData.getName()) + ", alias='"
-         + alias + ", select="
-         + select + ", type="
-         + type + '}';
-   }
 }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/actions/tables/query/expressions/AbstractFilterExpression.java

@@ -23,8 +23,6 @@ package com.kingsrook.qqq.backend.core.model.actions.tables.query.expressions;
 
 
 import java.io.Serializable;
-import java.util.Map;
-import com.kingsrook.qqq.backend.core.exceptions.QException;
 
 
 /*******************************************************************************
@@ -35,17 +33,7 @@ public abstract class AbstractFilterExpression<T extends Serializable> implement
    /*******************************************************************************
     **
     *******************************************************************************/
-   public abstract T evaluate() throws QException;
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   public T evaluateInputValues(Map<String, Serializable> inputValues) throws QException
-   {
-      return (T) this;
-   }
+   public abstract T evaluate();
 
 
 

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/actions/tables/query/expressions/FilterVariableExpression.java

@@ -1,214 +0,0 @@
-/*
- * 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.model.actions.tables.query.expressions;
-
-
-import java.io.Serializable;
-import java.util.Map;
-import com.kingsrook.qqq.backend.core.exceptions.QException;
-import com.kingsrook.qqq.backend.core.exceptions.QUserFacingException;
-import com.kingsrook.qqq.backend.core.utils.ValueUtils;
-
-
-/*******************************************************************************
- **
- *******************************************************************************/
-public class FilterVariableExpression extends AbstractFilterExpression<Serializable>
-{
-   private String variableName;
-   private String fieldName;
-   private String operator;
-   private int    valueIndex = 0;
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   @Override
-   public Serializable evaluate() throws QException
-   {
-      throw (new QUserFacingException("Missing variable value."));
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   @Override
-   public Serializable evaluateInputValues(Map<String, Serializable> inputValues) throws QException
-   {
-      if(!inputValues.containsKey(variableName) || "".equals(ValueUtils.getValueAsString(inputValues.get(variableName))))
-      {
-         throw (new QUserFacingException("Missing value for variable: " + variableName));
-      }
-      return (inputValues.get(variableName));
-   }
-
-
-
-   /*******************************************************************************
-    ** Constructor
-    **
-    *******************************************************************************/
-   public FilterVariableExpression()
-   {
-   }
-
-
-
-   /*******************************************************************************
-    ** Constructor
-    **
-    *******************************************************************************/
-   private FilterVariableExpression(String fieldName, int valueIndex)
-   {
-      this.fieldName = fieldName;
-      this.valueIndex = valueIndex;
-   }
-
-
-
-   /*******************************************************************************
-    ** Getter for valueIndex
-    *******************************************************************************/
-   public int getValueIndex()
-   {
-      return (this.valueIndex);
-   }
-
-
-
-   /*******************************************************************************
-    ** Setter for valueIndex
-    *******************************************************************************/
-   public void setValueIndex(int valueIndex)
-   {
-      this.valueIndex = valueIndex;
-   }
-
-
-
-   /*******************************************************************************
-    ** Fluent setter for valueIndex
-    *******************************************************************************/
-   public FilterVariableExpression withValueIndex(int valueIndex)
-   {
-      this.valueIndex = valueIndex;
-      return (this);
-   }
-
-
-
-   /*******************************************************************************
-    ** Getter for fieldName
-    *******************************************************************************/
-   public String getFieldName()
-   {
-      return (this.fieldName);
-   }
-
-
-
-   /*******************************************************************************
-    ** Setter for fieldName
-    *******************************************************************************/
-   public void setFieldName(String fieldName)
-   {
-      this.fieldName = fieldName;
-   }
-
-
-
-   /*******************************************************************************
-    ** Fluent setter for fieldName
-    *******************************************************************************/
-   public FilterVariableExpression withFieldName(String fieldName)
-   {
-      this.fieldName = fieldName;
-      return (this);
-   }
-
-
-
-   /*******************************************************************************
-    ** Getter for variableName
-    *******************************************************************************/
-   public String getVariableName()
-   {
-      return (this.variableName);
-   }
-
-
-
-   /*******************************************************************************
-    ** Setter for variableName
-    *******************************************************************************/
-   public void setVariableName(String variableName)
-   {
-      this.variableName = variableName;
-   }
-
-
-
-   /*******************************************************************************
-    ** Fluent setter for variableName
-    *******************************************************************************/
-   public FilterVariableExpression withVariableName(String variableName)
-   {
-      this.variableName = variableName;
-      return (this);
-   }
-
-
-
-   /*******************************************************************************
-    ** Getter for operator
-    *******************************************************************************/
-   public String getOperator()
-   {
-      return (this.operator);
-   }
-
-
-
-   /*******************************************************************************
-    ** Setter for operator
-    *******************************************************************************/
-   public void setOperator(String operator)
-   {
-      this.operator = operator;
-   }
-
-
-
-   /*******************************************************************************
-    ** Fluent setter for operator
-    *******************************************************************************/
-   public FilterVariableExpression withOperator(String operator)
-   {
-      this.operator = operator;
-      return (this);
-   }
-
-}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/actions/tables/query/expressions/Now.java

@@ -23,7 +23,6 @@ package com.kingsrook.qqq.backend.core.model.actions.tables.query.expressions;
 
 
 import java.time.Instant;
-import com.kingsrook.qqq.backend.core.exceptions.QException;
 
 
 /*******************************************************************************
@@ -36,7 +35,7 @@ public class Now extends AbstractFilterExpression<Instant>
     **
     *******************************************************************************/
    @Override
-   public Instant evaluate() throws QException
+   public Instant evaluate()
    {
       return (Instant.now());
    }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/actions/tables/query/expressions/NowWithOffset.java

@@ -28,7 +28,6 @@ import java.time.ZoneId;
 import java.time.ZoneOffset;
 import java.time.temporal.ChronoUnit;
 import java.util.concurrent.TimeUnit;
-import com.kingsrook.qqq.backend.core.exceptions.QException;
 
 
 /*******************************************************************************
@@ -120,7 +119,7 @@ public class NowWithOffset extends AbstractFilterExpression<Instant>
     **
     *******************************************************************************/
    @Override
-   public Instant evaluate() throws QException
+   public Instant evaluate()
    {
       /////////////////////////////////////////////////////////////////////////////
       // Instant doesn't let us plus/minus WEEK, MONTH, or YEAR...               //

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/actions/tables/query/expressions/ThisOrLastPeriod.java

@@ -28,7 +28,6 @@ import java.time.LocalDateTime;
 import java.time.ZoneId;
 import java.time.temporal.ChronoField;
 import java.time.temporal.ChronoUnit;
-import com.kingsrook.qqq.backend.core.exceptions.QException;
 import com.kingsrook.qqq.backend.core.exceptions.QRuntimeException;
 import com.kingsrook.qqq.backend.core.utils.ValueUtils;
 
@@ -96,7 +95,7 @@ public class ThisOrLastPeriod extends AbstractFilterExpression<Instant>
     **
     *******************************************************************************/
    @Override
-   public Instant evaluate() throws QException
+   public Instant evaluate()
    {
       ZoneId zoneId = ValueUtils.getSessionOrInstanceZoneId();
 

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/actions/tables/replace/ReplaceInput.java

@@ -39,9 +39,8 @@ public class ReplaceInput extends AbstractTableActionInput
    private UniqueKey           key;
    private List<QRecord>       records;
    private QQueryFilter        filter;
-   private boolean performDeletes                 = true;
-   private boolean allowNullKeyValuesToEqual      = false;
-   private boolean setPrimaryKeyInInsertedRecords = false;
+   private boolean             performDeletes            = true;
+   private boolean             allowNullKeyValuesToEqual = false;
 
    private boolean omitDmlAudit = false;
 
@@ -272,35 +271,4 @@ public class ReplaceInput extends AbstractTableActionInput
       return (this);
    }
 
-
-
-   /*******************************************************************************
-    ** Getter for setPrimaryKeyInInsertedRecords
-    *******************************************************************************/
-   public boolean getSetPrimaryKeyInInsertedRecords()
-   {
-      return (this.setPrimaryKeyInInsertedRecords);
-   }
-
-
-
-   /*******************************************************************************
-    ** Setter for setPrimaryKeyInInsertedRecords
-    *******************************************************************************/
-   public void setSetPrimaryKeyInInsertedRecords(boolean setPrimaryKeyInInsertedRecords)
-   {
-      this.setPrimaryKeyInInsertedRecords = setPrimaryKeyInInsertedRecords;
-   }
-
-
-
-   /*******************************************************************************
-    ** Fluent setter for setPrimaryKeyInInsertedRecords
-    *******************************************************************************/
-   public ReplaceInput withSetPrimaryKeyInInsertedRecords(boolean setPrimaryKeyInInsertedRecords)
-   {
-      this.setPrimaryKeyInInsertedRecords = setPrimaryKeyInInsertedRecords;
-      return (this);
-   }
-
 }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/actions/tables/update/UpdateInput.java

@@ -120,7 +120,7 @@ public class UpdateInput extends AbstractTableActionInput
    /*******************************************************************************
     **
     *******************************************************************************/
-   public UpdateInput withRecordEntities(List<? extends QRecordEntity> recordEntityList)
+   public UpdateInput withRecordEntities(List<QRecordEntity> recordEntityList)
    {
       for(QRecordEntity recordEntity : CollectionUtils.nonNullList(recordEntityList))
       {

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

@@ -54,7 +54,6 @@ public class CompositeWidgetData extends AbstractBlockWidgetData<CompositeWidget
       /////////////////////////////////////////////////////////////
       // note, these are used in QQQ FMD CompositeWidgetData.tsx //
       /////////////////////////////////////////////////////////////
-      FLEX_COLUMN,
       FLEX_ROW_WRAPPED,
       FLEX_ROW_SPACE_BETWEEN,
       TABLE_SUB_ROW_DETAILS,

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

@@ -1,188 +0,0 @@
-/*
- * QQQ - Low-code Application Framework for Engineers.
- * Copyright (C) 2021-2024.  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.model.dashboard.widgets;
-
-
-import java.util.List;
-import com.kingsrook.qqq.backend.core.model.data.QRecord;
-import com.kingsrook.qqq.backend.core.model.metadata.fields.QFieldMetaData;
-
-
-/*******************************************************************************
- **
- *******************************************************************************/
-public class DynamicFormWidgetData extends QWidgetData
-{
-   private List<QFieldMetaData> fieldList;
-
-   /////////////////////////////////////////////////////////////////////
-   // values for the fields -                                         //
-   // use a QRecord, so we can do "richer" things, like DisplayValues //
-   /////////////////////////////////////////////////////////////////////
-   private QRecord recordOfFieldValues;
-
-   /////////////////////////////////////////////////////
-   // if there are no fields, what message to display //
-   /////////////////////////////////////////////////////
-   private String noFieldsMessage;
-
-   ///////////////////////////////////////////////////////////////////////////////////
-   // what 1 field do we want to combine the dynamic fields into (as a JSON string) //
-   ///////////////////////////////////////////////////////////////////////////////////
-   private String mergedDynamicFormValuesIntoFieldName;
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   @Override
-   public String getType()
-   {
-      return WidgetType.DYNAMIC_FORM.getType();
-   }
-
-
-
-   /*******************************************************************************
-    ** Getter for fieldList
-    *******************************************************************************/
-   public List<QFieldMetaData> getFieldList()
-   {
-      return (this.fieldList);
-   }
-
-
-
-   /*******************************************************************************
-    ** Setter for fieldList
-    *******************************************************************************/
-   public void setFieldList(List<QFieldMetaData> fieldList)
-   {
-      this.fieldList = fieldList;
-   }
-
-
-
-   /*******************************************************************************
-    ** Fluent setter for fieldList
-    *******************************************************************************/
-   public DynamicFormWidgetData withFieldList(List<QFieldMetaData> fieldList)
-   {
-      this.fieldList = fieldList;
-      return (this);
-   }
-
-
-
-   /*******************************************************************************
-    ** Getter for noFieldsMessage
-    *******************************************************************************/
-   public String getNoFieldsMessage()
-   {
-      return (this.noFieldsMessage);
-   }
-
-
-
-   /*******************************************************************************
-    ** Setter for noFieldsMessage
-    *******************************************************************************/
-   public void setNoFieldsMessage(String noFieldsMessage)
-   {
-      this.noFieldsMessage = noFieldsMessage;
-   }
-
-
-
-   /*******************************************************************************
-    ** Fluent setter for noFieldsMessage
-    *******************************************************************************/
-   public DynamicFormWidgetData withNoFieldsMessage(String noFieldsMessage)
-   {
-      this.noFieldsMessage = noFieldsMessage;
-      return (this);
-   }
-
-
-
-   /*******************************************************************************
-    ** Getter for mergedDynamicFormValuesIntoFieldName
-    *******************************************************************************/
-   public String getMergedDynamicFormValuesIntoFieldName()
-   {
-      return (this.mergedDynamicFormValuesIntoFieldName);
-   }
-
-
-
-   /*******************************************************************************
-    ** Setter for mergedDynamicFormValuesIntoFieldName
-    *******************************************************************************/
-   public void setMergedDynamicFormValuesIntoFieldName(String mergedDynamicFormValuesIntoFieldName)
-   {
-      this.mergedDynamicFormValuesIntoFieldName = mergedDynamicFormValuesIntoFieldName;
-   }
-
-
-
-   /*******************************************************************************
-    ** Fluent setter for mergedDynamicFormValuesIntoFieldName
-    *******************************************************************************/
-   public DynamicFormWidgetData withMergedDynamicFormValuesIntoFieldName(String mergedDynamicFormValuesIntoFieldName)
-   {
-      this.mergedDynamicFormValuesIntoFieldName = mergedDynamicFormValuesIntoFieldName;
-      return (this);
-   }
-
-
-
-   /*******************************************************************************
-    ** Getter for recordOfFieldValues
-    *******************************************************************************/
-   public QRecord getRecordOfFieldValues()
-   {
-      return (this.recordOfFieldValues);
-   }
-
-
-
-   /*******************************************************************************
-    ** Setter for recordOfFieldValues
-    *******************************************************************************/
-   public void setRecordOfFieldValues(QRecord recordOfFieldValues)
-   {
-      this.recordOfFieldValues = recordOfFieldValues;
-   }
-
-
-
-   /*******************************************************************************
-    ** Fluent setter for recordOfFieldValues
-    *******************************************************************************/
-   public DynamicFormWidgetData withRecordOfFieldValues(QRecord recordOfFieldValues)
-   {
-      this.recordOfFieldValues = recordOfFieldValues;
-      return (this);
-   }
-
-}

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

@@ -1,196 +0,0 @@
-/*
- * 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.model.dashboard.widgets;
-
-
-import java.util.List;
-
-
-/*******************************************************************************
- ** Model containing datastructure expected by frontend filter and columns setup widget
- **
- *******************************************************************************/
-public class FilterAndColumnsSetupData extends QWidgetData
-{
-   private String       tableName;
-   private Boolean      allowVariables = false;
-   private Boolean      hideColumns    = false;
-   private List<String> filterDefaultFieldNames;
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   public FilterAndColumnsSetupData()
-   {
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   public FilterAndColumnsSetupData(String tableName, Boolean allowVariables, Boolean hideColumns, List<String> filterDefaultFieldNames)
-   {
-      this.tableName = tableName;
-      this.allowVariables = allowVariables;
-      this.hideColumns = hideColumns;
-      this.filterDefaultFieldNames = filterDefaultFieldNames;
-   }
-
-
-
-   /*******************************************************************************
-    ** Getter for type
-    **
-    *******************************************************************************/
-   public String getType()
-   {
-      return WidgetType.FILTER_AND_COLUMNS_SETUP.getType();
-   }
-
-
-
-   /*******************************************************************************
-    ** Getter for tableName
-    *******************************************************************************/
-   public String getTableName()
-   {
-      return (this.tableName);
-   }
-
-
-
-   /*******************************************************************************
-    ** Setter for tableName
-    *******************************************************************************/
-   public void setTableName(String tableName)
-   {
-      this.tableName = tableName;
-   }
-
-
-
-   /*******************************************************************************
-    ** Fluent setter for tableName
-    *******************************************************************************/
-   public FilterAndColumnsSetupData withTableName(String tableName)
-   {
-      this.tableName = tableName;
-      return (this);
-   }
-
-
-
-   /*******************************************************************************
-    ** Getter for hideColumns
-    *******************************************************************************/
-   public Boolean getHideColumns()
-   {
-      return (this.hideColumns);
-   }
-
-
-
-   /*******************************************************************************
-    ** Setter for hideColumns
-    *******************************************************************************/
-   public void setHideColumns(Boolean hideColumns)
-   {
-      this.hideColumns = hideColumns;
-   }
-
-
-
-   /*******************************************************************************
-    ** Fluent setter for hideColumns
-    *******************************************************************************/
-   public FilterAndColumnsSetupData withHideColumns(Boolean hideColumns)
-   {
-      this.hideColumns = hideColumns;
-      return (this);
-   }
-
-
-
-   /*******************************************************************************
-    ** Getter for filterDefaultFieldNames
-    *******************************************************************************/
-   public List<String> getFilterDefaultFieldNames()
-   {
-      return (this.filterDefaultFieldNames);
-   }
-
-
-
-   /*******************************************************************************
-    ** Setter for filterDefaultFieldNames
-    *******************************************************************************/
-   public void setFilterDefaultFieldNames(List<String> filterDefaultFieldNames)
-   {
-      this.filterDefaultFieldNames = filterDefaultFieldNames;
-   }
-
-
-
-   /*******************************************************************************
-    ** Fluent setter for filterDefaultFieldNames
-    *******************************************************************************/
-   public FilterAndColumnsSetupData withFilterDefaultFieldNames(List<String> filterDefaultFieldNames)
-   {
-      this.filterDefaultFieldNames = filterDefaultFieldNames;
-      return (this);
-   }
-
-
-
-   /*******************************************************************************
-    ** Getter for allowVariables
-    *******************************************************************************/
-   public Boolean getAllowVariables()
-   {
-      return (this.allowVariables);
-   }
-
-
-
-   /*******************************************************************************
-    ** Setter for allowVariables
-    *******************************************************************************/
-   public void setAllowVariables(Boolean allowVariables)
-   {
-      this.allowVariables = allowVariables;
-   }
-
-
-
-   /*******************************************************************************
-    ** Fluent setter for allowVariables
-    *******************************************************************************/
-   public FilterAndColumnsSetupData withAllowVariables(Boolean allowVariables)
-   {
-      this.allowVariables = allowVariables;
-      return (this);
-   }
-
-}

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

@@ -1,97 +0,0 @@
-/*
- * 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.model.dashboard.widgets;
-
-
-import java.util.List;
-
-
-/*******************************************************************************
- ** Model containing datastructure expected by frontend bar chart widget
- **
- *******************************************************************************/
-public class MultiTableData extends QWidgetData
-{
-   List<TableData> tableDataList;
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   public MultiTableData()
-   {
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   public MultiTableData(List<TableData> tableDataList)
-   {
-      setTableDataList(tableDataList);
-   }
-
-
-
-   /*******************************************************************************
-    ** Getter for type
-    **
-    *******************************************************************************/
-   public String getType()
-   {
-      return WidgetType.MULTI_TABLE.getType();
-   }
-
-
-
-   /*******************************************************************************
-    ** Getter for tableDataList
-    *******************************************************************************/
-   public List<TableData> getTableDataList()
-   {
-      return (this.tableDataList);
-   }
-
-
-
-   /*******************************************************************************
-    ** Setter for tableDataList
-    *******************************************************************************/
-   public void setTableDataList(List<TableData> tableDataList)
-   {
-      this.tableDataList = tableDataList;
-   }
-
-
-
-   /*******************************************************************************
-    ** Fluent setter for tableDataList
-    *******************************************************************************/
-   public MultiTableData withTableDataList(List<TableData> tableDataList)
-   {
-      this.tableDataList = tableDataList;
-      return (this);
-   }
-
-}

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

@@ -27,12 +27,10 @@ package com.kingsrook.qqq.backend.core.model.dashboard.widgets;
  *******************************************************************************/
 public enum WidgetType
 {
-   ///////////////////////////////////
-   // (generally) dashboard widgets //
-   ///////////////////////////////////
    ALERT("alert"),
    BAR_CHART("barChart"),
    CHART("chart"),
+   CHILD_RECORD_LIST("childRecordList"),
    DIVIDER("divider"),
    FIELD_VALUE_LIST("fieldValueList"),
    GENERIC("generic"),
@@ -42,35 +40,20 @@ public enum WidgetType
    SMALL_LINE_CHART("smallLineChart"),
    LOCATION("location"),
    MULTI_STATISTICS("multiStatistics"),
-   MULTI_TABLE("multiTable"),
+   PARENT_WIDGET("parentWidget"),
    PIE_CHART("pieChart"),
+   PROCESS("process"),
    QUICK_SIGHT_CHART("quickSightChart"),
    STATISTICS("statistics"),
    STACKED_BAR_CHART("stackedBarChart"),
    STEPPER("stepper"),
    TABLE("table"),
    USA_MAP("usaMap"),
-
-   ///////////////////////////////
-   // widget to house a process //
-   ///////////////////////////////
-   PROCESS("process"),
-
-   ///////////////////////
-   // container widgets //
-   ///////////////////////
-   PARENT_WIDGET("parentWidget"),
    COMPOSITE("composite"),
-
-   //////////////////////////////
-   // record view/edit widgets //
-   //////////////////////////////
-   CHILD_RECORD_LIST("childRecordList"),
-   DYNAMIC_FORM("dynamicForm"),
    DATA_BAG_VIEWER("dataBagViewer"),
-   PIVOT_TABLE_SETUP("pivotTableSetup"),
-   FILTER_AND_COLUMNS_SETUP("filterAndColumnsSetup"),
-   SCRIPT_VIEWER("scriptViewer");
+   SCRIPT_VIEWER("scriptViewer"),
+   REPORT_SETUP("reportSetup"),
+   PIVOT_TABLE_SETUP("pivotTableSetup");
 
 
    private final String type;

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/data/QField.java

@@ -49,11 +49,6 @@ public @interface QField
     *******************************************************************************/
    String backendName() default "";
 
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   boolean isPrimaryKey() default false;
-
    /*******************************************************************************
     **
     *******************************************************************************/

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/data/QIgnore.java

@@ -1,39 +0,0 @@
-/*
- * QQQ - Low-code Application Framework for Engineers.
- * Copyright (C) 2021-2024.  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.model.data;
-
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-
-/*******************************************************************************
- ** Marker - that a piece of code should be ignored (e.g., a field not treated as
- ** a @QField)
- *******************************************************************************/
-@Target({ ElementType.FIELD, ElementType.METHOD })
-@Retention(RetentionPolicy.RUNTIME)
-public @interface QIgnore
-{
-}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/data/QRecord.java

@@ -35,15 +35,12 @@ import java.util.LinkedHashMap;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
-import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
 import com.kingsrook.qqq.backend.core.logging.QLogger;
 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.QErrorMessage;
 import com.kingsrook.qqq.backend.core.model.statusmessages.QWarningMessage;
-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.lang3.SerializationUtils;
 import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
@@ -465,7 +462,6 @@ public class QRecord implements Serializable
    }
 
 
-
    /*******************************************************************************
     ** Getter for a single field's value
     **
@@ -620,22 +616,6 @@ public class QRecord implements Serializable
 
 
 
-   /*******************************************************************************
-    ** Getter for errors
-    **
-    *******************************************************************************/
-   @JsonIgnore
-   public String getErrorsAsString()
-   {
-      if(CollectionUtils.nullSafeHasContents(errors))
-      {
-         return StringUtils.join("; ", errors.stream().map(e -> e.getMessage()).toList());
-      }
-      return ("");
-   }
-
-
-
    /*******************************************************************************
     ** Setter for errors
     **
@@ -752,22 +732,6 @@ public class QRecord implements Serializable
 
 
 
-   /*******************************************************************************
-    ** Getter for warnings
-    **
-    *******************************************************************************/
-   @JsonIgnore
-   public String getWarningsAsString()
-   {
-      if(CollectionUtils.nullSafeHasContents(warnings))
-      {
-         return StringUtils.join("; ", warnings.stream().map(e -> e.getMessage()).toList());
-      }
-      return ("");
-   }
-
-
-
    /*******************************************************************************
     ** Setter for warnings
     *******************************************************************************/
@@ -778,18 +742,6 @@ public class QRecord implements Serializable
 
 
 
-   /*******************************************************************************
-    ** Fluently Add one warning to this record
-    **
-    *******************************************************************************/
-   public QRecord withWarning(QWarningMessage warning)
-   {
-      addWarning(warning);
-      return (this);
-   }
-
-
-
    /*******************************************************************************
     ** Fluent setter for warnings
     *******************************************************************************/

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/data/QRecordEntity.java

@@ -218,7 +218,6 @@ public abstract class QRecordEntity
    }
 
 
-
    /*******************************************************************************
     **
     *******************************************************************************/
@@ -297,19 +296,7 @@ public abstract class QRecordEntity
                   }
                   else
                   {
-                     Optional<QIgnore>      ignoreAnnotation      = getQIgnoreAnnotation(c, fieldName);
-                     Optional<QAssociation> associationAnnotation = getQAssociationAnnotation(c, fieldName);
-
-                     if(ignoreAnnotation.isPresent() || associationAnnotation.isPresent())
-                     {
-                        ////////////////////////////////////////////////////////////
-                        // silently skip if marked as an association or an ignore //
-                        ////////////////////////////////////////////////////////////
-                     }
-                     else
-                     {
-                        LOG.debug("Skipping field without @QField annotation", logPair("class", c.getSimpleName()), logPair("fieldName", fieldName));
-                     }
+                     LOG.debug("Skipping field without @QField annotation", logPair("class", c.getSimpleName()), logPair("fieldName", fieldName));
                   }
                }
                else
@@ -373,16 +360,6 @@ public abstract class QRecordEntity
 
 
 
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   public static Optional<QIgnore> getQIgnoreAnnotation(Class<? extends QRecordEntity> c, String ignoreName)
-   {
-      return (getAnnotationOnField(c, QIgnore.class, ignoreName));
-   }
-
-
-
    /*******************************************************************************
     **
     *******************************************************************************/
@@ -442,9 +419,9 @@ public abstract class QRecordEntity
          }
          else
          {
-            if(!method.getName().equals("getClass") && method.getAnnotation(QIgnore.class) == null)
+            if(!method.getName().equals("getClass"))
             {
-               LOG.debug("Method [" + method.getName() + "] in [" + method.getDeclaringClass().getSimpleName() + "] looks like a getter, but its return type, [" + method.getReturnType().getSimpleName() + "], isn't supported.");
+               LOG.debug("Method [" + method.getName() + "] looks like a getter, but its return type, [" + method.getReturnType() + "], isn't supported.");
             }
          }
       }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/data/QRecordEnum.java

@@ -145,7 +145,7 @@ public interface QRecordEnum
          {
             if(!method.getName().equals("getClass") && !method.getName().equals("getDeclaringClass") && !method.getName().equals("getPossibleValueId"))
             {
-               LOG.debug("Method [" + method.getName() + "] in [" + method.getDeclaringClass().getSimpleName() + "] looks like a getter, but its return type, [" + method.getReturnType().getSimpleName() + "], isn't supported.");
+               LOG.debug("Method [" + method.getName() + "] looks like a getter, but its return type, [" + method.getReturnType() + "], isn't supported.");
             }
          }
       }

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

@@ -30,7 +30,7 @@ import com.kingsrook.qqq.backend.core.model.MetaDataProducerInterface;
  ** MetaDataProducerHelper, to put point at a package full of these, and populate
  ** your whole QInstance.
  *******************************************************************************/
-public abstract class MetaDataProducer<T extends MetaDataProducerOutput> implements MetaDataProducerInterface<T>
+public abstract class MetaDataProducer<T extends TopLevelMetaDataInterface> implements MetaDataProducerInterface<T>
 {
 
 }

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

@@ -27,16 +27,11 @@ import java.lang.reflect.Constructor;
 import java.lang.reflect.Modifier;
 import java.util.ArrayList;
 import java.util.Comparator;
-import java.util.HashMap;
 import java.util.List;
-import java.util.Map;
-import com.google.common.collect.ImmutableSet;
 import com.google.common.reflect.ClassPath;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
 import com.kingsrook.qqq.backend.core.logging.QLogger;
 import com.kingsrook.qqq.backend.core.model.MetaDataProducerInterface;
-import com.kingsrook.qqq.backend.core.model.metadata.dashboard.QWidgetMetaData;
-import com.kingsrook.qqq.backend.core.model.metadata.joins.QJoinMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.layout.QAppMetaData;
 import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
 
@@ -48,30 +43,7 @@ public class MetaDataProducerHelper
 {
    private static final QLogger LOG = QLogger.getLogger(MetaDataProducerHelper.class);
 
-   private static Map<Class<?>, Integer> comparatorValuesByType = new HashMap<>();
-   private static Integer                defaultComparatorValue;
 
-   private static ImmutableSet<ClassPath.ClassInfo> topLevelClasses;
-
-   static
-   {
-      ////////////////////////////////////////////////////////////////////////////////////////
-      // define how we break ties in sort-order based on the meta-dta type.  e.g., do apps  //
-      // after all other types (as apps often try to get other types from the instance)     //
-      // also - do backends earlier than others (e.g., tables may expect backends to exist) //
-      // any types not in the map get the default value.                                    //
-      ////////////////////////////////////////////////////////////////////////////////////////
-      comparatorValuesByType.put(QBackendMetaData.class, 1);
-
-      /////////////////////////////////////
-      // unspecified ones will come here //
-      /////////////////////////////////////
-      defaultComparatorValue = 10;
-
-      comparatorValuesByType.put(QJoinMetaData.class, 21);
-      comparatorValuesByType.put(QWidgetMetaData.class, 22);
-      comparatorValuesByType.put(QAppMetaData.class, 23);
-   }
 
    /*******************************************************************************
     ** Recursively find all classes in the given package, that implement MetaDataProducerInterface
@@ -130,9 +102,11 @@ public class MetaDataProducerHelper
          }
       }
 
-      /////////////////////////////////////////////////////////////////////////////////////////////
-      // sort them by sort order, then by the type that they return, as set up in the static map //
-      /////////////////////////////////////////////////////////////////////////////////////////////
+      ////////////////////////////////////////////////////////////////////////////////////////////
+      // sort them by sort order, then by the type that they return - specifically - doing apps //
+      // after all other types (as apps often try to get other types from the instance)         //
+      // also - do backends earlier than others (e.g., tables may expect backends to exist)     //
+      ////////////////////////////////////////////////////////////////////////////////////////////
       producers.sort(Comparator
          .comparing((MetaDataProducerInterface<?> p) -> p.getSortOrder())
          .thenComparing((MetaDataProducerInterface<?> p) ->
@@ -140,7 +114,18 @@ public class MetaDataProducerHelper
             try
             {
                Class<?> outputType = p.getClass().getMethod("produce", QInstance.class).getReturnType();
-               return comparatorValuesByType.getOrDefault(outputType, defaultComparatorValue);
+               if(outputType.equals(QAppMetaData.class))
+               {
+                  return (2);
+               }
+               else if(outputType.equals(QBackendMetaData.class))
+               {
+                  return (0);
+               }
+               else
+               {
+                  return (1);
+               }
             }
             catch(Exception e)
             {
@@ -157,7 +142,7 @@ public class MetaDataProducerHelper
          {
             try
             {
-               MetaDataProducerOutput metaData = producer.produce(instance);
+               TopLevelMetaDataInterface metaData = producer.produce(instance);
                if(metaData != null)
                {
                   metaData.addSelfToInstance(instance);
@@ -187,7 +172,7 @@ public class MetaDataProducerHelper
       List<Class<?>> classes = new ArrayList<>();
       ClassLoader    loader  = Thread.currentThread().getContextClassLoader();
 
-      for(ClassPath.ClassInfo info : getTopLevelClasses(loader))
+      for(ClassPath.ClassInfo info : ClassPath.from(loader).getTopLevelClasses())
       {
          if(info.getName().startsWith(packageName))
          {
@@ -198,29 +183,4 @@ public class MetaDataProducerHelper
       return (classes);
    }
 
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   private static ImmutableSet<ClassPath.ClassInfo> getTopLevelClasses(ClassLoader loader) throws IOException
-   {
-      if(topLevelClasses == null)
-      {
-         topLevelClasses = ClassPath.from(loader).getTopLevelClasses();
-      }
-
-      return (topLevelClasses);
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   public static void clearTopLevelClassCache()
-   {
-      topLevelClasses = null;
-   }
-
 }

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

@@ -1,101 +0,0 @@
-/*
- * QQQ - Low-code Application Framework for Engineers.
- * Copyright (C) 2021-2024.  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.model.metadata;
-
-
-import java.util.ArrayList;
-import java.util.List;
-import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
-
-
-/*******************************************************************************
- ** Output object for a MetaDataProducer, which contains multiple meta-data
- ** objects.
- *******************************************************************************/
-public class MetaDataProducerMultiOutput implements MetaDataProducerOutput
-{
-   private List<MetaDataProducerOutput> contents;
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   @Override
-   public void addSelfToInstance(QInstance instance)
-   {
-      for(MetaDataProducerOutput metaDataProducerOutput : CollectionUtils.nonNullList(contents))
-      {
-         metaDataProducerOutput.addSelfToInstance(instance);
-      }
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   public void add(MetaDataProducerOutput metaDataProducerOutput)
-   {
-      if(contents == null)
-      {
-         contents = new ArrayList<>();
-      }
-      contents.add(metaDataProducerOutput);
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   public MetaDataProducerMultiOutput with(MetaDataProducerOutput metaDataProducerOutput)
-   {
-      add(metaDataProducerOutput);
-      return (this);
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   public <T extends MetaDataProducerOutput> List<T> getEach(Class<T> c)
-   {
-      List<T> rs = new ArrayList<>();
-
-      for(MetaDataProducerOutput content : contents)
-      {
-         if(content instanceof MetaDataProducerMultiOutput multiOutput)
-         {
-            rs.addAll(multiOutput.getEach(c));
-         }
-         else if(c.isInstance(content))
-         {
-            rs.add(c.cast(content));
-         }
-      }
-
-      return (rs);
-   }
-
-}

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

@@ -1,40 +0,0 @@
-/*
- * QQQ - Low-code Application Framework for Engineers.
- * Copyright (C) 2021-2024.  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.model.metadata;
-
-
-/*******************************************************************************
- ** Interface to mark objects that can be produced by a MetaDataProducer.
- **
- ** These would usually be TopLevelMetaData objects (a table, a process, etc)
- ** but can also be a MetaDataProducerMultiOutput, to produce multiple objects
- ** from one producer.
- *******************************************************************************/
-public interface MetaDataProducerOutput
-{
-
-   /*******************************************************************************
-    ** call the appropriate methods on a QInstance to add ourselves to it.
-    *******************************************************************************/
-   void addSelfToInstance(QInstance instance);
-
-}

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

@@ -155,6 +155,18 @@ public class QBackendMetaData implements TopLevelMetaDataInterface
 
 
 
+   /*******************************************************************************
+    ** Fluent setter, returning generically, to help sub-class fluent flows
+    *******************************************************************************/
+   @SuppressWarnings("unchecked")
+   public <T extends QBackendMetaData> T withBackendType(String backendType)
+   {
+      this.backendType = backendType;
+      return (T) this;
+   }
+
+
+
    /*******************************************************************************
     **
     *******************************************************************************/

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

@@ -46,7 +46,6 @@ import com.kingsrook.qqq.backend.core.model.metadata.frontend.AppTreeNode;
 import com.kingsrook.qqq.backend.core.model.metadata.frontend.AppTreeNodeType;
 import com.kingsrook.qqq.backend.core.model.metadata.joins.QJoinMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.layout.QAppMetaData;
-import com.kingsrook.qqq.backend.core.model.metadata.messaging.QMessagingProviderMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.permissions.QPermissionRules;
 import com.kingsrook.qqq.backend.core.model.metadata.possiblevalues.QPossibleValueSource;
 import com.kingsrook.qqq.backend.core.model.metadata.processes.QProcessMetaData;
@@ -79,7 +78,6 @@ public class QInstance
    private QAuthenticationMetaData                  authentication      = null;
    private QBrandingMetaData                        branding            = null;
    private Map<String, QAutomationProviderMetaData> automationProviders = new HashMap<>();
-   private Map<String, QMessagingProviderMetaData> messagingProviders = new HashMap<>();
 
    ////////////////////////////////////////////////////////////////////////////////////////////
    // Important to use LinkedHashmap here, to preserve the order in which entries are added. //
@@ -741,53 +739,6 @@ public class QInstance
 
 
 
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   public void addMessagingProvider(QMessagingProviderMetaData messagingProvider)
-   {
-      String name = messagingProvider.getName();
-      if(this.messagingProviders.containsKey(name))
-      {
-         throw (new IllegalArgumentException("Attempted to add a second messagingProvider with name: " + name));
-      }
-      this.messagingProviders.put(name, messagingProvider);
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   public QMessagingProviderMetaData getMessagingProvider(String name)
-   {
-      return (this.messagingProviders.get(name));
-   }
-
-
-
-   /*******************************************************************************
-    ** Getter for messagingProviders
-    **
-    *******************************************************************************/
-   public Map<String, QMessagingProviderMetaData> getMessagingProviders()
-   {
-      return messagingProviders;
-   }
-
-
-
-   /*******************************************************************************
-    ** Setter for messagingProviders
-    **
-    *******************************************************************************/
-   public void setMessagingProviders(Map<String, QMessagingProviderMetaData> messagingProviders)
-   {
-      this.messagingProviders = messagingProviders;
-   }
-
-
-
    /*******************************************************************************
     ** Getter for hasBeenValidated
     **

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

@@ -26,7 +26,7 @@ package com.kingsrook.qqq.backend.core.model.metadata;
  ** Interface for meta-data classes that can be added directly (e.g, at the top
  ** level) to a QInstance (such as a QTableMetaData - not a QFieldMetaData).
  *******************************************************************************/
-public interface TopLevelMetaDataInterface extends MetaDataProducerOutput
+public interface TopLevelMetaDataInterface
 {
 
    /*******************************************************************************

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/metadata/fields/DateTimeDisplayValueBehavior.java

@@ -93,13 +93,7 @@ public class DateTimeDisplayValueBehavior implements FieldDisplayBehavior<DateTi
       {
          try
          {
-            Instant instant = record.getValueInstant(field.getName());
-
-            if(instant == null)
-            {
-               continue;
-            }
-
+            Instant       instant       = record.getValueInstant(field.getName());
             ZonedDateTime zonedDateTime = instant.atZone(ZoneId.of(defaultZoneId));
             record.setDisplayValue(field.getName(), QValueFormatter.formatDateTimeWithZone(zonedDateTime));
          }
@@ -121,57 +115,35 @@ public class DateTimeDisplayValueBehavior implements FieldDisplayBehavior<DateTi
       {
          try
          {
-            Instant instant = record.getValueInstant(field.getName());
-            if(instant == null)
+            Instant instant    = record.getValueInstant(field.getName());
+            String  zoneString = record.getValueString(zoneIdFromFieldName);
+
+            ZoneId zoneId;
+            try
             {
-               continue;
+               zoneId = ZoneId.of(zoneString);
             }
-
-            String zoneString = record.getValueString(zoneIdFromFieldName);
-
-            ZoneId zoneId = null;
-            if(StringUtils.hasContent(zoneString))
-            {
-               try
-               {
-                  zoneId = ZoneId.of(zoneString);
-               }
-               catch(Exception e)
-               {
-                  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-                  // we probably(?) don't need a stack trace here (and it could get noisy?), so just info w/ the exception message... //
-                  // and we expect this might be somewhat frequent, if you might have invalid values in your zoneId field...          //
-                  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-                  LOG.info("Exception applying zoneIdFromFieldName behavior", logPair("message", e.getMessage()), logPair("table", table.getName()), logPair("field", field.getName()), logPair("id", record.getValue(table.getPrimaryKeyField())));
-               }
-            }
-
-            if(zoneId == null)
+            catch(Exception e)
             {
                ////////////////////////////////////////////////////////////////////////////////////////////////
                // if the zone string from the other field isn't valid, and we have a fallback, try to use it //
                ////////////////////////////////////////////////////////////////////////////////////////////////
                if(StringUtils.hasContent(fallbackZoneId))
                {
-                  ////////////////////////////////////////////////////////////////////////////////////////////
-                  // assume that validation has confirmed this is a valid zone - so no try-catch right here //
-                  ////////////////////////////////////////////////////////////////////////////////////////////
                   zoneId = ZoneId.of(fallbackZoneId);
                }
+               else
+               {
+                  throw (e);
+               }
             }
 
-            if(zoneId != null)
-            {
-               ZonedDateTime zonedDateTime = instant.atZone(zoneId);
-               record.setDisplayValue(field.getName(), QValueFormatter.formatDateTimeWithZone(zonedDateTime));
-            }
+            ZonedDateTime zonedDateTime = instant.atZone(zoneId);
+            record.setDisplayValue(field.getName(), QValueFormatter.formatDateTimeWithZone(zonedDateTime));
          }
          catch(Exception e)
          {
-            ///////////////////////////////////////////////////////////////////////
-            // we don't expect this to ever hit - so warn it w/ stack if it does //
-            ///////////////////////////////////////////////////////////////////////
-            LOG.warn("Unexpected error applying zoneIdFromFieldName behavior", e, logPair("table", table.getName()), logPair("field", field.getName()), logPair("id", record.getValue(table.getPrimaryKeyField())));
+            LOG.info("Error applying zoneIdFromFieldName DateTimeDisplayValueBehavior", e, logPair("table", table.getName()), logPair("field", field.getName()), logPair("id", record.getValue(table.getPrimaryKeyField())));
          }
       }
    }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/metadata/fields/DisplayFormat.java

@@ -49,6 +49,7 @@ public interface DisplayFormat
    /*******************************************************************************
     **
     *******************************************************************************/
+   @SuppressWarnings("checkstyle:Indentation")
    static String getExcelFormat(String javaDisplayFormat)
    {
       if(javaDisplayFormat == null)
@@ -57,21 +58,21 @@ public interface DisplayFormat
       }
 
       return switch(javaDisplayFormat)
-      {
-         case DisplayFormat.DEFAULT -> null;
-         case DisplayFormat.COMMAS -> "#,##0";
-         case DisplayFormat.DECIMAL1 -> "0.0";
-         case DisplayFormat.DECIMAL2 -> "0.00";
-         case DisplayFormat.DECIMAL3 -> "0.000";
-         case DisplayFormat.DECIMAL1_COMMAS -> "#,##0.0";
-         case DisplayFormat.DECIMAL2_COMMAS -> "#,##0.00";
-         case DisplayFormat.DECIMAL3_COMMAS -> "#,##0.000";
-         case DisplayFormat.CURRENCY -> "$#,##0.00";
-         case DisplayFormat.PERCENT -> "0%";
-         case DisplayFormat.PERCENT_POINT1 -> "0.0%";
-         case DisplayFormat.PERCENT_POINT2 -> "0.00%";
-         default -> null;
-      };
+         {
+            case DisplayFormat.DEFAULT -> null;
+            case DisplayFormat.COMMAS -> "#,##0";
+            case DisplayFormat.DECIMAL1 -> "0.0";
+            case DisplayFormat.DECIMAL2 -> "0.00";
+            case DisplayFormat.DECIMAL3 -> "0.000";
+            case DisplayFormat.DECIMAL1_COMMAS -> "#,##0.0";
+            case DisplayFormat.DECIMAL2_COMMAS -> "#,##0.00";
+            case DisplayFormat.DECIMAL3_COMMAS -> "#,##0.000";
+            case DisplayFormat.CURRENCY -> "$#,##0.00";
+            case DisplayFormat.PERCENT -> "0%";
+            case DisplayFormat.PERCENT_POINT1 -> "0.0%";
+            case DisplayFormat.PERCENT_POINT2 -> "0.00%";
+            default -> null;
+         };
 
    }
 }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/metadata/frontend/QFrontendTableMetaData.java

@@ -39,7 +39,6 @@ import com.kingsrook.qqq.backend.core.model.actions.AbstractActionInput;
 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.fields.QFieldMetaData;
-import com.kingsrook.qqq.backend.core.model.metadata.sharing.ShareableTableMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.tables.Capability;
 import com.kingsrook.qqq.backend.core.model.metadata.tables.ExposedJoin;
 import com.kingsrook.qqq.backend.core.model.metadata.tables.QFieldSection;
@@ -76,8 +75,6 @@ public class QFrontendTableMetaData
    private boolean usesVariants;
    private String  variantTableLabel;
 
-   private ShareableTableMetaData shareableTableMetaData;
-
    //////////////////////////////////////////////////////////////////////////////////
    // do not add setters.  take values from the source-object in the constructor!! //
    //////////////////////////////////////////////////////////////////////////////////
@@ -107,8 +104,6 @@ public class QFrontendTableMetaData
          }
 
          this.sections = tableMetaData.getSections();
-
-         this.shareableTableMetaData = tableMetaData.getShareableTableMetaData();
       }
 
       if(includeJoins)
@@ -372,14 +367,4 @@ public class QFrontendTableMetaData
       return (this.variantTableLabel);
    }
 
-
-
-   /*******************************************************************************
-    ** Getter for shareableTableMetaData
-    **
-    *******************************************************************************/
-   public ShareableTableMetaData getShareableTableMetaData()
-   {
-      return shareableTableMetaData;
-   }
 }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/metadata/joins/JoinType.java

@@ -44,13 +44,14 @@ public enum JoinType
    /*******************************************************************************
     **
     *******************************************************************************/
+   @SuppressWarnings("checkstyle:indentation")
    public JoinType flip()
    {
       return switch(this)
-      {
-         case ONE_TO_MANY -> MANY_TO_ONE;
-         case MANY_TO_ONE -> ONE_TO_MANY;
-         case MANY_TO_MANY, ONE_TO_ONE -> this;
-      };
+         {
+            case ONE_TO_MANY -> MANY_TO_ONE;
+            case MANY_TO_ONE -> ONE_TO_MANY;
+            case MANY_TO_MANY, ONE_TO_ONE -> this;
+         };
    }
 }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/metadata/messaging/QMessagingProviderMetaData.java

@@ -1,110 +0,0 @@
-/*
- * QQQ - Low-code Application Framework for Engineers.
- * Copyright (C) 2021-2024.  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.model.metadata.messaging;
-
-
-import com.kingsrook.qqq.backend.core.model.metadata.QInstance;
-import com.kingsrook.qqq.backend.core.model.metadata.TopLevelMetaDataInterface;
-
-
-/*******************************************************************************
- ** Base class for qqq messaging-providers.  e.g., a connection to an outbound
- ** email service, or, for example, Slack.
- *******************************************************************************/
-public class QMessagingProviderMetaData implements TopLevelMetaDataInterface
-{
-   private String name;
-   private String type;
-
-
-
-   /*******************************************************************************
-    ** Getter for name
-    *******************************************************************************/
-   public String getName()
-   {
-      return (this.name);
-   }
-
-
-
-   /*******************************************************************************
-    ** Setter for name
-    *******************************************************************************/
-   public void setName(String name)
-   {
-      this.name = name;
-   }
-
-
-
-   /*******************************************************************************
-    ** Fluent setter for name
-    *******************************************************************************/
-   public QMessagingProviderMetaData withName(String name)
-   {
-      this.name = name;
-      return (this);
-   }
-
-
-
-   /*******************************************************************************
-    ** Getter for type
-    *******************************************************************************/
-   public String getType()
-   {
-      return (this.type);
-   }
-
-
-
-   /*******************************************************************************
-    ** Setter for type
-    *******************************************************************************/
-   public void setType(String type)
-   {
-      this.type = type;
-   }
-
-
-
-   /*******************************************************************************
-    ** Fluent setter for type
-    *******************************************************************************/
-   public QMessagingProviderMetaData withType(String type)
-   {
-      this.type = type;
-      return (this);
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   @Override
-   public void addSelfToInstance(QInstance qInstance)
-   {
-      qInstance.addMessagingProvider(this);
-   }
-}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/metadata/messaging/email/EmailMessagingProvider.java

@@ -1,56 +0,0 @@
-/*
- * QQQ - Low-code Application Framework for Engineers.
- * Copyright (C) 2021-2024.  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.model.metadata.messaging.email;
-
-
-import com.kingsrook.qqq.backend.core.exceptions.QException;
-import com.kingsrook.qqq.backend.core.model.actions.messaging.SendMessageInput;
-import com.kingsrook.qqq.backend.core.model.actions.messaging.SendMessageOutput;
-import com.kingsrook.qqq.backend.core.modules.messaging.MessagingProviderInterface;
-
-
-/*******************************************************************************
- **
- *******************************************************************************/
-public class EmailMessagingProvider implements MessagingProviderInterface
-{
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   @Override
-   public String getType()
-   {
-      return (EmailMessagingProviderMetaData.TYPE);
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   @Override
-   public SendMessageOutput sendMessage(SendMessageInput sendMessageInput) throws QException
-   {
-      return new SendEmailAction().sendMessage(sendMessageInput);
-   }
-}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/metadata/messaging/email/EmailMessagingProviderMetaData.java

@@ -1,116 +0,0 @@
-/*
- * QQQ - Low-code Application Framework for Engineers.
- * Copyright (C) 2021-2024.  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.model.metadata.messaging.email;
-
-
-import com.kingsrook.qqq.backend.core.model.metadata.messaging.QMessagingProviderMetaData;
-import com.kingsrook.qqq.backend.core.modules.messaging.QMessagingProviderDispatcher;
-
-
-/*******************************************************************************
- **
- *******************************************************************************/
-public class EmailMessagingProviderMetaData extends QMessagingProviderMetaData
-{
-   private String smtpServer;
-   private String smtpPort;
-
-   public static final String TYPE = "EMAIL";
-
-   static
-   {
-      QMessagingProviderDispatcher.registerMessagingProvider(new EmailMessagingProvider());
-   }
-
-   /*******************************************************************************
-    ** Constructor
-    **
-    *******************************************************************************/
-   public EmailMessagingProviderMetaData()
-   {
-      super();
-      setType(TYPE);
-   }
-
-
-
-   /*******************************************************************************
-    ** Getter for smtpServer
-    *******************************************************************************/
-   public String getSmtpServer()
-   {
-      return (this.smtpServer);
-   }
-
-
-
-   /*******************************************************************************
-    ** Setter for smtpServer
-    *******************************************************************************/
-   public void setSmtpServer(String smtpServer)
-   {
-      this.smtpServer = smtpServer;
-   }
-
-
-
-   /*******************************************************************************
-    ** Fluent setter for smtpServer
-    *******************************************************************************/
-   public EmailMessagingProviderMetaData withSmtpServer(String smtpServer)
-   {
-      this.smtpServer = smtpServer;
-      return (this);
-   }
-
-
-
-   /*******************************************************************************
-    ** Getter for smtpPort
-    *******************************************************************************/
-   public String getSmtpPort()
-   {
-      return (this.smtpPort);
-   }
-
-
-
-   /*******************************************************************************
-    ** Setter for smtpPort
-    *******************************************************************************/
-   public void setSmtpPort(String smtpPort)
-   {
-      this.smtpPort = smtpPort;
-   }
-
-
-
-   /*******************************************************************************
-    ** Fluent setter for smtpPort
-    *******************************************************************************/
-   public EmailMessagingProviderMetaData withSmtpPort(String smtpPort)
-   {
-      this.smtpPort = smtpPort;
-      return (this);
-   }
-
-}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/metadata/messaging/email/SendEmailAction.java

@@ -1,216 +0,0 @@
-/*
- * QQQ - Low-code Application Framework for Engineers.
- * Copyright (C) 2021-2024.  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.model.metadata.messaging.email;
-
-
-import java.io.UnsupportedEncodingException;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Properties;
-import com.kingsrook.qqq.backend.core.context.QContext;
-import com.kingsrook.qqq.backend.core.exceptions.QException;
-import com.kingsrook.qqq.backend.core.model.actions.messaging.Content;
-import com.kingsrook.qqq.backend.core.model.actions.messaging.MultiParty;
-import com.kingsrook.qqq.backend.core.model.actions.messaging.Party;
-import com.kingsrook.qqq.backend.core.model.actions.messaging.PartyRole;
-import com.kingsrook.qqq.backend.core.model.actions.messaging.SendMessageInput;
-import com.kingsrook.qqq.backend.core.model.actions.messaging.SendMessageOutput;
-import com.kingsrook.qqq.backend.core.model.actions.messaging.email.EmailContentRole;
-import com.kingsrook.qqq.backend.core.model.actions.messaging.email.EmailPartyRole;
-import com.kingsrook.qqq.backend.core.utils.StringUtils;
-import jakarta.mail.Address;
-import jakarta.mail.Message;
-import jakarta.mail.Multipart;
-import jakarta.mail.Session;
-import jakarta.mail.Transport;
-import jakarta.mail.internet.AddressException;
-import jakarta.mail.internet.InternetAddress;
-import jakarta.mail.internet.MimeBodyPart;
-import jakarta.mail.internet.MimeMessage;
-import jakarta.mail.internet.MimeMultipart;
-
-
-/*******************************************************************************
- **
- *******************************************************************************/
-public class SendEmailAction
-{
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   public SendMessageOutput sendMessage(SendMessageInput sendMessageInput) throws QException
-   {
-      EmailMessagingProviderMetaData messagingProvider = (EmailMessagingProviderMetaData) QContext.getQInstance().getMessagingProvider(sendMessageInput.getMessagingProviderName());
-
-      /////////////////////////////////////////
-      // set up properties to make a session //
-      /////////////////////////////////////////
-      Properties properties = new Properties();
-      properties.setProperty("mail.smtp.host", messagingProvider.getSmtpServer());
-      properties.setProperty("mail.smtp.port", messagingProvider.getSmtpPort());
-      Session session = Session.getInstance(properties);
-
-      try
-      {
-         ////////////////////////////////////////////
-         // Construct a default MimeMessage object //
-         ////////////////////////////////////////////
-         MimeMessage emailMessage = new MimeMessage(session);
-         emailMessage.setSubject(sendMessageInput.getSubject());
-
-         Party to = sendMessageInput.getTo();
-         if(to instanceof MultiParty toMultiParty)
-         {
-            for(Party party : toMultiParty.getPartyList())
-            {
-               addRecipient(emailMessage, party);
-            }
-         }
-         else
-         {
-            addRecipient(emailMessage, to);
-         }
-
-         Party from = sendMessageInput.getFrom();
-         if(from instanceof MultiParty fromMultiParty)
-         {
-            for(Party party : fromMultiParty.getPartyList())
-            {
-               addSender(emailMessage, party);
-            }
-         }
-         else
-         {
-            addSender(emailMessage, from);
-         }
-
-         Multipart multipart = new MimeMultipart();
-         for(Content content : sendMessageInput.getContentList())
-         {
-            if(EmailContentRole.HTML.equals(content.getContentRole()))
-            {
-               MimeBodyPart mimeBodyPart = new MimeBodyPart();
-               mimeBodyPart.setContent(content.getBody(), "text/html; charset=utf-8");
-               multipart.addBodyPart(mimeBodyPart);
-            }
-            else if(EmailContentRole.TEXT.equals(content.getContentRole()))
-            {
-               MimeBodyPart mimeBodyPart = new MimeBodyPart();
-               mimeBodyPart.setContent(content.getBody(), "text/plain; charset=utf-8");
-               multipart.addBodyPart(mimeBodyPart);
-            }
-         }
-
-         emailMessage.setContent(multipart);
-
-         /////////////
-         // send it //
-         /////////////
-         Transport.send(emailMessage);
-         System.out.println("Message dispatched successfully...");
-      }
-      catch(Exception e)
-      {
-         throw (new QException("Error sending email", e));
-      }
-
-      return null;
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   private void addSender(MimeMessage emailMessage, Party party) throws Exception
-   {
-      if(EmailPartyRole.REPLY_TO.equals(party.getRole()))
-      {
-         InternetAddress internetAddress = getInternetAddressFromParty(party);
-         Address[]       replyTo         = emailMessage.getReplyTo();
-         if(replyTo == null || replyTo.length == 0)
-         {
-            emailMessage.setReplyTo(new Address[] { internetAddress });
-         }
-         else
-         {
-            List<Address> replyToList = Arrays.asList(replyTo);
-            emailMessage.setReplyTo(replyToList.toArray(new Address[0]));
-         }
-      }
-      else if(party.getRole() == null || PartyRole.Default.DEFAULT.equals(party.getRole()) || EmailPartyRole.FROM.equals(party.getRole()))
-      {
-         emailMessage.setFrom(getInternetAddressFromParty(party));
-      }
-      else
-      {
-         throw (new QException("Unrecognized sender role [" + party.getRole() + "]"));
-      }
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   private void addRecipient(MimeMessage emailMessage, Party party) throws Exception
-   {
-      Message.RecipientType recipientType;
-      if(EmailPartyRole.CC.equals(party.getRole()))
-      {
-         recipientType = Message.RecipientType.CC;
-      }
-      else if(EmailPartyRole.BCC.equals(party.getRole()))
-      {
-         recipientType = Message.RecipientType.BCC;
-      }
-      else if(party.getRole() == null || PartyRole.Default.DEFAULT.equals(party.getRole()) || EmailPartyRole.TO.equals(party.getRole()))
-      {
-         recipientType = Message.RecipientType.TO;
-      }
-      else
-      {
-         throw (new QException("Unrecognized recipient role [" + party.getRole() + "]"));
-      }
-
-      InternetAddress internetAddress = getInternetAddressFromParty(party);
-      emailMessage.addRecipient(recipientType, internetAddress);
-      System.out.println("add recipient: [" + recipientType + "] => [" + internetAddress + "]");
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   private static InternetAddress getInternetAddressFromParty(Party party) throws AddressException, UnsupportedEncodingException
-   {
-      InternetAddress internetAddress = new InternetAddress(party.getAddress());
-      if(StringUtils.hasContent(party.getLabel()))
-      {
-         internetAddress.setPersonal(party.getLabel());
-      }
-      return internetAddress;
-   }
-
-}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/metadata/messaging/ses/SESMessagingProvider.java

@@ -1,56 +0,0 @@
-/*
- * QQQ - Low-code Application Framework for Engineers.
- * Copyright (C) 2021-2024.  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.model.metadata.messaging.ses;
-
-
-import com.kingsrook.qqq.backend.core.exceptions.QException;
-import com.kingsrook.qqq.backend.core.model.actions.messaging.SendMessageInput;
-import com.kingsrook.qqq.backend.core.model.actions.messaging.SendMessageOutput;
-import com.kingsrook.qqq.backend.core.modules.messaging.MessagingProviderInterface;
-
-
-/*******************************************************************************
- **
- *******************************************************************************/
-public class SESMessagingProvider implements MessagingProviderInterface
-{
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   @Override
-   public String getType()
-   {
-      return (SESMessagingProviderMetaData.TYPE);
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   @Override
-   public SendMessageOutput sendMessage(SendMessageInput sendMessageInput) throws QException
-   {
-      return new SendSESAction().sendMessage(sendMessageInput);
-   }
-}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/metadata/messaging/ses/SESMessagingProviderMetaData.java

@@ -1,148 +0,0 @@
-/*
- * QQQ - Low-code Application Framework for Engineers.
- * Copyright (C) 2021-2024.  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.model.metadata.messaging.ses;
-
-
-import com.kingsrook.qqq.backend.core.model.metadata.messaging.QMessagingProviderMetaData;
-import com.kingsrook.qqq.backend.core.modules.messaging.QMessagingProviderDispatcher;
-
-
-/*******************************************************************************
- **
- *******************************************************************************/
-public class SESMessagingProviderMetaData extends QMessagingProviderMetaData
-{
-   private String accessKey;
-   private String secretKey;
-   private String region;
-
-   public static final String TYPE = "SES";
-
-   static
-   {
-      QMessagingProviderDispatcher.registerMessagingProvider(new SESMessagingProvider());
-   }
-
-   /*******************************************************************************
-    ** Constructor
-    **
-    *******************************************************************************/
-   public SESMessagingProviderMetaData()
-   {
-      super();
-      setType(TYPE);
-   }
-
-
-
-   /*******************************************************************************
-    ** Getter for accessKey
-    *******************************************************************************/
-   public String getAccessKey()
-   {
-      return (this.accessKey);
-   }
-
-
-
-   /*******************************************************************************
-    ** Setter for accessKey
-    *******************************************************************************/
-   public void setAccessKey(String accessKey)
-   {
-      this.accessKey = accessKey;
-   }
-
-
-
-   /*******************************************************************************
-    ** Fluent setter for accessKey
-    *******************************************************************************/
-   public SESMessagingProviderMetaData withAccessKey(String accessKey)
-   {
-      this.accessKey = accessKey;
-      return (this);
-   }
-
-
-
-   /*******************************************************************************
-    ** Getter for secretKey
-    *******************************************************************************/
-   public String getSecretKey()
-   {
-      return (this.secretKey);
-   }
-
-
-
-   /*******************************************************************************
-    ** Setter for secretKey
-    *******************************************************************************/
-   public void setSecretKey(String secretKey)
-   {
-      this.secretKey = secretKey;
-   }
-
-
-
-   /*******************************************************************************
-    ** Fluent setter for secretKey
-    *******************************************************************************/
-   public SESMessagingProviderMetaData withSecretKey(String secretKey)
-   {
-      this.secretKey = secretKey;
-      return (this);
-   }
-
-
-
-   /*******************************************************************************
-    ** Getter for region
-    *******************************************************************************/
-   public String getRegion()
-   {
-      return (this.region);
-   }
-
-
-
-   /*******************************************************************************
-    ** Setter for region
-    *******************************************************************************/
-   public void setRegion(String region)
-   {
-      this.region = region;
-   }
-
-
-
-   /*******************************************************************************
-    ** Fluent setter for region
-    *******************************************************************************/
-   public SESMessagingProviderMetaData withRegion(String region)
-   {
-      this.region = region;
-      return (this);
-   }
-
-}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/metadata/messaging/ses/SendSESAction.java

@@ -1,335 +0,0 @@
-/*
- * QQQ - Low-code Application Framework for Engineers.
- * Copyright (C) 2021-2024.  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.model.metadata.messaging.ses;
-
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import com.amazonaws.auth.AWSStaticCredentialsProvider;
-import com.amazonaws.auth.BasicAWSCredentials;
-import com.amazonaws.services.simpleemail.AmazonSimpleEmailService;
-import com.amazonaws.services.simpleemail.AmazonSimpleEmailServiceClientBuilder;
-import com.amazonaws.services.simpleemail.model.Body;
-import com.amazonaws.services.simpleemail.model.Content;
-import com.amazonaws.services.simpleemail.model.Destination;
-import com.amazonaws.services.simpleemail.model.Message;
-import com.amazonaws.services.simpleemail.model.SendEmailRequest;
-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.messaging.MultiParty;
-import com.kingsrook.qqq.backend.core.model.actions.messaging.Party;
-import com.kingsrook.qqq.backend.core.model.actions.messaging.PartyRole;
-import com.kingsrook.qqq.backend.core.model.actions.messaging.SendMessageInput;
-import com.kingsrook.qqq.backend.core.model.actions.messaging.SendMessageOutput;
-import com.kingsrook.qqq.backend.core.model.actions.messaging.email.EmailContentRole;
-import com.kingsrook.qqq.backend.core.model.actions.messaging.email.EmailPartyRole;
-import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
-
-
-/*******************************************************************************
- **
- *******************************************************************************/
-public class SendSESAction
-{
-   private static final QLogger LOG = QLogger.getLogger(SendSESAction.class);
-
-   private AmazonSimpleEmailService amazonSES;
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   public SendMessageOutput sendMessage(SendMessageInput sendMessageInput) throws QException
-   {
-      try
-      {
-         AmazonSimpleEmailService client = getAmazonSES(sendMessageInput);
-
-         ///////////////////////////////////
-         // build up a send email request //
-         ///////////////////////////////////
-         SendEmailRequest request = new SendEmailRequest()
-            .withSource(getSource(sendMessageInput))
-            .withReplyToAddresses(getReplyTos(sendMessageInput))
-            .withDestination(buildDestination(sendMessageInput))
-            .withMessage(buildMessage(sendMessageInput));
-
-         client.sendEmail(request);
-         LOG.info("SES Message [" + request.getMessage().getSubject().getData() + "] was sent to [" + request.getDestination().toString() + "].");
-      }
-      catch(Exception e)
-      {
-         String message = "An unexpected error occurred sending an SES message.";
-         throw (new QException(message, e));
-      }
-
-      return (null);
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   Message buildMessage(SendMessageInput input) throws QException
-   {
-      ///////////////////////////////////////////////////////////////////////////////////////////////
-      // iterate over all contents of our input, looking for an HTML and Text version of the email //
-      ///////////////////////////////////////////////////////////////////////////////////////////////
-      Body body = new Body();
-      for(com.kingsrook.qqq.backend.core.model.actions.messaging.Content content : CollectionUtils.nonNullList(input.getContentList()))
-      {
-         if(EmailContentRole.TEXT.equals(content.getContentRole()))
-         {
-            body.setText(new Content().withCharset("UTF-8").withData(content.getBody()));
-         }
-         else if(EmailContentRole.HTML.equals(content.getContentRole()))
-         {
-            body.setHtml(new Content().withCharset("UTF-8").withData(content.getBody()));
-         }
-      }
-
-      ////////////////////////////////////////////////
-      // error if no text or html body was provided //
-      ////////////////////////////////////////////////
-      if(body.getText() == null && body.getHtml() == null)
-      {
-         throw (new QException("Cannot send SES message because neither a 'Text' nor an 'HTML' body was provided."));
-      }
-
-      ////////////////////////////////////////
-      // warning if no subject was provided //
-      ////////////////////////////////////////
-      Message message = new Message();
-      message.setBody(body);
-
-      /////////////////////////////////////
-      // warn if no subject was provided //
-      /////////////////////////////////////
-      if(input.getSubject() == null)
-      {
-         LOG.warn("Sending SES message with no subject.");
-      }
-      else
-      {
-         message.setSubject(new Content().withCharset("UTF-8").withData(input.getSubject()));
-      }
-
-      return (message);
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   List<String> getReplyTos(SendMessageInput input) throws QException
-   {
-      ////////////////////////////
-      // no input, no reply tos //
-      ////////////////////////////
-      if(input == null)
-      {
-         return (Collections.emptyList());
-      }
-
-      ///////////////////////////////////////
-      // build up a list of froms if multi //
-      ///////////////////////////////////////
-      List<Party> partyList = getPartyListFromParty(input.getFrom());
-      if(partyList == null)
-      {
-         return (Collections.emptyList());
-      }
-
-      ///////////////////////////////
-      // only get reply to parties //
-      ///////////////////////////////
-      List<Party> replyToParties = partyList.stream().filter(p -> EmailPartyRole.REPLY_TO.equals(p.getRole())).toList();
-
-      //////////////////////////////////
-      // get addresses from reply tos //
-      //////////////////////////////////
-      List<String> replyTos = replyToParties.stream().map(Party::getAddress).toList();
-
-      /////////////////////////////
-      // return the from address //
-      /////////////////////////////
-      return (replyTos);
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   String getSource(SendMessageInput input) throws QException
-   {
-      ///////////////////////////////
-      // error if no from provided //
-      ///////////////////////////////
-      if(input.getFrom() == null)
-      {
-         throw (new QException("Cannot send SES message because a FROM was not provided."));
-      }
-
-      ///////////////////////////////////////
-      // build up a list of froms if multi //
-      ///////////////////////////////////////
-      List<Party> partyList = getPartyListFromParty(input.getFrom());
-
-      ///////////////////////////////////////
-      // remove any roles that aren't FROM //
-      ///////////////////////////////////////
-      partyList.removeIf(p -> p.getRole() != null && !EmailPartyRole.FROM.equals(p.getRole()));
-
-      ///////////////////////////////////////////////////////////////////////////////////////////
-      // if no froms found, error, if more than one found, log a warning and use the first one //
-      ///////////////////////////////////////////////////////////////////////////////////////////
-      if(partyList.isEmpty())
-      {
-         throw (new QException("Cannot send SES message because a FROM was not provided."));
-      }
-      else if(partyList.size() > 1)
-      {
-         LOG.warn("More than one FROM value was found, will send using the first one found [" + partyList.get(0).getAddress() + "].");
-      }
-
-      /////////////////////////////
-      // return the from address //
-      /////////////////////////////
-      return (partyList.get(0).getAddress());
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   List<Party> getPartyListFromParty(Party party)
-   {
-      //////////////////////////////////////////////
-      // get all parties into one list of parties //
-      //////////////////////////////////////////////
-      List<Party> partyList = new ArrayList<>();
-      if(party != null)
-      {
-         if(party instanceof MultiParty toMultiParty)
-         {
-            partyList.addAll(toMultiParty.getPartyList());
-         }
-         else
-         {
-            partyList.add(party);
-         }
-      }
-      return (partyList);
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   Destination buildDestination(SendMessageInput input) throws QException
-   {
-      ////////////////////////////////////////////////////////////////////
-      // iterate over the parties putting it the proper party type list //
-      ////////////////////////////////////////////////////////////////////
-      List<String> toList  = new ArrayList<>();
-      List<String> ccList  = new ArrayList<>();
-      List<String> bccList = new ArrayList<>();
-
-      List<Party> partyList = getPartyListFromParty(input.getTo());
-      for(Party party : partyList)
-      {
-         if(EmailPartyRole.CC.equals(party.getRole()))
-         {
-            ccList.add(party.getAddress());
-         }
-         else if(EmailPartyRole.BCC.equals(party.getRole()))
-         {
-            bccList.add(party.getAddress());
-         }
-         else if(party.getRole() == null || PartyRole.Default.DEFAULT.equals(party.getRole()) || EmailPartyRole.TO.equals(party.getRole()))
-         {
-            toList.add(party.getAddress());
-         }
-         else
-         {
-            throw (new QException("An unrecognized recipient role of [" + party.getRole() + "] was provided."));
-         }
-      }
-
-      //////////////////////////////////////////
-      // if no to addresses, this is an error //
-      //////////////////////////////////////////
-      if(toList.isEmpty())
-      {
-         throw (new QException("Cannot send SES message because no TO addresses were provided."));
-      }
-
-      /////////////////////////////////////////////
-      // build and return aws destination object //
-      /////////////////////////////////////////////
-      return (new Destination()
-         .withToAddresses(toList)
-         .withCcAddresses(ccList)
-         .withBccAddresses(bccList));
-   }
-
-
-
-   /*******************************************************************************
-    ** Set the amazonSES object.
-    *******************************************************************************/
-   public void setAmazonSES(AmazonSimpleEmailService amazonSES)
-   {
-      this.amazonSES = amazonSES;
-   }
-
-
-
-   /*******************************************************************************
-    ** Internal accessor for the amazonSES object - should always use this, not the field.
-    *******************************************************************************/
-   protected AmazonSimpleEmailService getAmazonSES(SendMessageInput sendMessageInput)
-   {
-      if(amazonSES == null)
-      {
-         SESMessagingProviderMetaData messagingProvider = (SESMessagingProviderMetaData) QContext.getQInstance().getMessagingProvider(sendMessageInput.getMessagingProviderName());
-
-         /////////////////////////////////////////////
-         // get credentials and build an SES client //
-         /////////////////////////////////////////////
-         BasicAWSCredentials credentials = new BasicAWSCredentials(messagingProvider.getAccessKey(), messagingProvider.getSecretKey());
-         amazonSES = AmazonSimpleEmailServiceClientBuilder.standard()
-            .withCredentials(new AWSStaticCredentialsProvider(credentials))
-            .withRegion(messagingProvider.getRegion()).build();
-      }
-
-      return amazonSES;
-   }
-}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/metadata/possiblevalues/QPossibleValueSource.java

@@ -53,7 +53,6 @@ public class QPossibleValueSource implements TopLevelMetaDataInterface
    // for type = TABLE //
    //////////////////////
    private String               tableName;
-   private String overrideIdField;
    private List<String>         searchFields;
    private List<QFilterOrderBy> orderByFields;
 
@@ -631,35 +630,4 @@ public class QPossibleValueSource implements TopLevelMetaDataInterface
       qInstance.addPossibleValueSource(this);
    }
 
-
-
-   /*******************************************************************************
-    ** Getter for overrideIdField
-    *******************************************************************************/
-   public String getOverrideIdField()
-   {
-      return (this.overrideIdField);
-   }
-
-
-
-   /*******************************************************************************
-    ** Setter for overrideIdField
-    *******************************************************************************/
-   public void setOverrideIdField(String overrideIdField)
-   {
-      this.overrideIdField = overrideIdField;
-   }
-
-
-
-   /*******************************************************************************
-    ** Fluent setter for overrideIdField
-    *******************************************************************************/
-   public QPossibleValueSource withOverrideIdField(String overrideIdField)
-   {
-      this.overrideIdField = overrideIdField;
-      return (this);
-   }
-
 }