Merge branch 'rel/0.20.0'

Convert Kingsrook/qqq to GitHub Actions

.github/actions/install_asciidoctor/action.yml

@@ -0,0 +1,10 @@
+name: install_asciidoctor
+runs:
+  using: composite
+  steps:
+  - uses: actions/checkout@v4.1.0
+  - name: Install asciidoctor
+    run: |-
+      sudo apt-get update
+      sudo apt install -y asciidoctor
+    shell: bash

.github/actions/install_java17/action.yml

@@ -0,0 +1,16 @@
+name: install_java17
+runs:
+  using: composite
+  steps:
+  - name: Install Java 17
+    run: |-
+      sudo apt-get update
+      sudo apt install -y openjdk-17-jdk
+      sudo rm /etc/alternatives/java
+      sudo ln -s /usr/lib/jvm/java-17-openjdk-amd64/bin/java /etc/alternatives/java
+    shell: bash
+  - name: Install html2text
+    run: |-
+      sudo apt-get update
+      sudo apt-get install -y html2text
+    shell: bash

.github/actions/mvn_jar_deploy/action.yml

@@ -0,0 +1,22 @@
+name: mvn_jar_deploy
+runs:
+  using: composite
+  steps:
+  - uses: actions/checkout@v4.1.0
+  - name: Adjust pom version
+    run: ".circleci/adjust-pom-version.sh"
+    shell: bash
+  - name: restore_cache
+    uses: actions/cache@v3.3.2
+    with:
+      key: v1-dependencies-{{ checksum "pom.xml" }}
+      path: UPDATE_ME
+      restore-keys: v1-dependencies-{{ checksum "pom.xml" }}
+  - name: Run Maven Jar Deploy
+    run: mvn -s .circleci/mvn-settings.xml -T4 flatten:flatten jar:jar deploy:deploy
+    shell: bash
+  - name: save_cache
+    uses: actions/cache@v3.3.2
+    with:
+      path: "~/.m2"
+      key: v1-dependencies-{{ checksum "pom.xml" }}

.github/actions/mvn_verify/action.yml

@@ -0,0 +1,61 @@
+name: mvn_verify
+runs:
+  using: composite
+  steps:
+  - uses: actions/checkout@v4.1.0
+  - name: restore_cache
+    uses: actions/cache@v3.3.2
+    with:
+      key: v1-dependencies-{{ checksum "pom.xml" }}
+      path: UPDATE_ME
+      restore-keys: v1-dependencies-{{ checksum "pom.xml" }}
+  - name: Write .env
+    run: echo "RDBMS_PASSWORD=$RDBMS_PASSWORD" >> qqq-sample-project/.env
+    shell: bash
+  - name: Run Maven Verify
+    run: mvn -s .circleci/mvn-settings.xml -T4 verify
+    shell: bash
+  - uses: "./.github/actions/store_jacoco_site"
+    with:
+      module: qqq-backend-core
+  - uses: "./.github/actions/store_jacoco_site"
+    with:
+      module: qqq-backend-module-filesystem
+  - uses: "./.github/actions/store_jacoco_site"
+    with:
+      module: qqq-backend-module-rdbms
+  - uses: "./.github/actions/store_jacoco_site"
+    with:
+      module: qqq-backend-module-api
+  - uses: "./.github/actions/store_jacoco_site"
+    with:
+      module: qqq-middleware-api
+  - uses: "./.github/actions/store_jacoco_site"
+    with:
+      module: qqq-middleware-javalin
+  - uses: "./.github/actions/store_jacoco_site"
+    with:
+      module: qqq-middleware-picocli
+  - uses: "./.github/actions/store_jacoco_site"
+    with:
+      module: qqq-middleware-slack
+  - uses: "./.github/actions/store_jacoco_site"
+    with:
+      module: qqq-language-support-javascript
+  - uses: "./.github/actions/store_jacoco_site"
+    with:
+      module: qqq-sample-project
+  - name: Save test results
+    run: |-
+      mkdir -p ~/test-results/junit/
+      find . -type f -regex ".*/target/surefire-reports/.*xml" -exec cp {} ~/test-results/junit/ \;
+    if: always()
+    shell: bash
+  - uses: actions/upload-artifact@v4.1.0
+    with:
+      path: "~/test-results"
+  - name: save_cache
+    uses: actions/cache@v3.3.2
+    with:
+      path: "~/.m2"
+      key: v1-dependencies-{{ checksum "pom.xml" }}

.github/actions/run_asciidoctor/action.yml

@@ -0,0 +1,9 @@
+name: run_asciidoctor
+runs:
+  using: composite
+  steps:
+  - name: Run asciidoctor
+    run: |-
+      cd docs
+      asciidoctor -a docinfo=shared index.adoc
+    shell: bash

.github/actions/store_jacoco_site/action.yml

@@ -0,0 +1,13 @@
+name: store_jacoco_site
+inputs:
+  module:
+    required: false
+runs:
+  using: composite
+  steps:
+  - uses: actions/upload-artifact@v4.1.0
+    with:
+      path: "${{ inputs.module }}/target/site/jacoco/index.html"
+  - uses: actions/upload-artifact@v4.1.0
+    with:
+      path: "${{ inputs.module }}/target/site/jacoco/jacoco-resources"

.github/actions/upload_docs_site/action.yml

@@ -0,0 +1,9 @@
+name: upload_docs_site
+runs:
+  using: composite
+  steps:
+  - name: scp html to justinsgotskinnylegs.com
+    run: |-
+      cd docs
+      scp index.html dkelkhoff@45.79.44.221:/mnt/first-volume/dkelkhoff/nginx/html/justinsgotskinnylegs.com/qqq-docs.html
+    shell: bash

.github/workflows/codacy.yml

@@ -0,0 +1,61 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+
+# This workflow checks out code, performs a Codacy security scan
+# and integrates the results with the
+# GitHub Advanced Security code scanning feature.  For more information on
+# the Codacy security scan action usage and parameters, see
+# https://github.com/codacy/codacy-analysis-cli-action.
+# For more information on Codacy Analysis CLI in general, see
+# https://github.com/codacy/codacy-analysis-cli.
+
+name: Codacy Security Scan
+
+on:
+  push:
+    branches: [ "security" ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ "security" ]
+  schedule:
+    - cron: '26 5 * * 4'
+
+permissions:
+  contents: read
+
+jobs:
+  codacy-security-scan:
+    permissions:
+      contents: read # for actions/checkout to fetch code
+      security-events: write # for github/codeql-action/upload-sarif to upload SARIF results
+      actions: read # only required for a private repository by github/codeql-action/upload-sarif to get the Action run status
+    name: Codacy Security Scan
+    runs-on: ubuntu-latest
+    steps:
+      # Checkout the repository to the GitHub Actions runner
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      # Execute Codacy Analysis CLI and generate a SARIF output with the security issues identified during the analysis
+      - name: Run Codacy Analysis CLI
+        uses: codacy/codacy-analysis-cli-action@d840f886c4bd4edc059706d09c6a1586111c540b
+        with:
+          # Check https://github.com/codacy/codacy-analysis-cli#project-token to get your project token from your Codacy repository
+          # You can also omit the token and run the tools that support default configurations
+          project-token: ${{ secrets.CODACY_PROJECT_TOKEN }}
+          verbose: true
+          output: results.sarif
+          format: sarif
+          # Adjust severity of non-security issues
+          gh-code-scanning-compat: true
+          # Force 0 exit code to allow SARIF file generation
+          # This will handover control about PR rejection to the GitHub side
+          max-allowed-issues: 2147483647
+
+      # Upload the SARIF file generated in the previous step
+      - name: Upload SARIF results file
+        uses: github/codeql-action/upload-sarif@v2
+        with:
+          sarif_file: results.sarif

.github/workflows/codeql.yml

@@ -0,0 +1,93 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ "security" ]
+  pull_request:
+    branches: [ "security" ]
+  schedule:
+    - cron: '31 10 * * 3'
+
+jobs:
+  analyze:
+    name: Analyze (${{ matrix.language }})
+    # Runner size impacts CodeQL analysis time. To learn more, please see:
+    #   - https://gh.io/recommended-hardware-resources-for-running-codeql
+    #   - https://gh.io/supported-runners-and-hardware-resources
+    #   - https://gh.io/using-larger-runners (GitHub.com only)
+    # Consider using larger runners or machines with greater resources for possible analysis time improvements.
+    runs-on: ${{ (matrix.language == 'swift' && 'macos-latest') || 'ubuntu-latest' }}
+    timeout-minutes: ${{ (matrix.language == 'swift' && 120) || 360 }}
+    permissions:
+      # required for all workflows
+      security-events: write
+
+      # required to fetch internal or private CodeQL packs
+      packages: read
+
+      # only required for workflows in private repositories
+      actions: read
+      contents: read
+
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+        - language: java-kotlin
+          build-mode: none # This mode only analyzes Java. Set this to 'autobuild' or 'manual' to analyze Kotlin too.
+        # CodeQL supports the following values keywords for 'language': 'c-cpp', 'csharp', 'go', 'java-kotlin', 'javascript-typescript', 'python', 'ruby', 'swift'
+        # Use `c-cpp` to analyze code written in C, C++ or both
+        # Use 'java-kotlin' to analyze code written in Java, Kotlin or both
+        # Use 'javascript-typescript' to analyze code written in JavaScript, TypeScript or both
+        # To learn more about changing the languages that are analyzed or customizing the build mode for your analysis,
+        # see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/customizing-your-advanced-setup-for-code-scanning.
+        # If you are analyzing a compiled language, you can modify the 'build-mode' for that language to customize how
+        # your codebase is analyzed, see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/codeql-code-scanning-for-compiled-languages
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v3
+      with:
+        languages: ${{ matrix.language }}
+        build-mode: ${{ matrix.build-mode }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+
+        # For more details on CodeQL's query packs, refer to: https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
+        # queries: security-extended,security-and-quality
+
+    # If the analyze step fails for one of the languages you are analyzing with
+    # "We were unable to automatically build your code", modify the matrix above
+    # to set the build mode to "manual" for that language. Then modify this step
+    # to build your code.
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
+    - if: matrix.build-mode == 'manual'
+      shell: bash
+      run: |
+        echo 'If you are using a "manual" build mode for one or more of the' \
+          'languages you are analyzing, replace this with the commands to build' \
+          'your code, for example:'
+        echo '  make bootstrap'
+        echo '  make release'
+        exit 1
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v3
+      with:
+        category: "/language:${{matrix.language}}"

.github/workflows/deploy.yml

@@ -0,0 +1,20 @@
+name: Kingsrook/qqq/deploy
+on:
+  push:
+    branches:
+    - release
+jobs:
+  mvn_deploy:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4.1.0
+    - uses: "./.github/actions/install_java17"
+    - uses: "./.github/actions/mvn_verify"
+    - uses: "./.github/actions/mvn_jar_deploy"
+  publish_asciidoc:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4.1.0
+    - uses: "./.github/actions/install_asciidoctor"
+    - uses: "./.github/actions/run_asciidoctor"
+    - uses: "./.github/actions/upload_docs_site"

.github/workflows/test_only.yml

@@ -0,0 +1,12 @@
+name: Kingsrook/qqq/test_only
+on:
+  push:
+    branches:
+    - release
+jobs:
+  mvn_test:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4.1.0
+    - uses: "./.github/actions/install_java17"
+    - uses: "./.github/actions/mvn_verify"

.gitignore

@@ -35,3 +35,5 @@ hs_err_pid*
 *.swp
 .flattened-pom.xml
 dependency-reduced-pom.xml
+/.env.local
+/.cache/

README.md

@@ -19,7 +19,7 @@ You can also use fine-grained jars:
 
 ## License
 QQQ - Low-code Application Framework for Engineers. \
-Copyright (C) 2022.  Kingsrook, LLC \
+Copyright (C) 2020-2024.  Kingsrook, LLC \
 651 N Broad St Ste 205 # 6917 | Middletown DE 19709 | United States \
 contact@kingsrook.com | https://github.com/Kingsrook/
 

SECURITY.md

@@ -0,0 +1,21 @@
+# Security Policy
+
+## Supported Versions
+
+Use this section to tell people about which versions of your project are
+currently being supported with security updates.
+
+| Version | Supported          |
+| ------- | ------------------ |
+| 5.1.x   | :white_check_mark: |
+| 5.0.x   | :x:                |
+| 4.0.x   | :white_check_mark: |
+| < 4.0   | :x:                |
+
+## Reporting a Vulnerability
+
+Use this section to tell people how to report a vulnerability.
+
+Tell them where to go, how often they can expect to get an update on a
+reported vulnerability, what to expect if the vulnerability is accepted or
+declined, etc.

docs/metaData/Fields.adoc

@@ -117,3 +117,19 @@ new QTableMetaData().withName("flights").withFields(List.of(
       .withBehavior(new DateTimeDisplayValueBehavior()
          .withDefaultZoneId("UTC"))
 ----
+
+===== CaseChangeBehavior
+A field can be made to always go through a toUpperCase or toLowerCase transformation, both before it is stored in a backend,
+and after it is read from a backend, by adding a CaseChangeBehavior to it:
+
+[source,java]
+.Examples of using CaseChangeBehavior
+----
+new QTableMetaData().withName("item").withFields(List.of(
+
+   new QFieldMetaData("sku", QFieldType.STRING)
+      .withBehavior(CaseChangeBehavior.TO_UPPER_CASE)),
+
+   new QFieldMetaData("username", QFieldType.STRING)
+      .withBehavior(CaseChangeBehavior.TO_LOWER_CASE)),
+----

pom.xml

@@ -46,7 +46,7 @@
    </modules>
 
    <properties>
-      <revision>0.20.0-SNAPSHOT</revision>
+      <revision>0.20.0</revision>
 
       <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
       <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
@@ -55,7 +55,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>
@@ -209,6 +209,7 @@
                   <productionBranch>main</productionBranch>
                   <developmentBranch>dev</developmentBranch>
                   <versionTagPrefix>version-</versionTagPrefix>
+                  <releaseBranchPrefix>rel/</releaseBranchPrefix>
                </gitFlowConfig>
                <skipFeatureVersion>true</skipFeatureVersion> <!-- Keep feature names out of versions -->
                <postReleaseGoals>install</postReleaseGoals>  <!-- Let CI run deploys -->

qodana.yaml

@@ -0,0 +1,31 @@
+#-------------------------------------------------------------------------------#
+#               Qodana analysis is configured by qodana.yaml file               #
+#             https://www.jetbrains.com/help/qodana/qodana-yaml.html            #
+#-------------------------------------------------------------------------------#
+version: "1.0"
+
+#Specify inspection profile for code analysis
+profile:
+  name: qodana.starter
+
+#Enable inspections
+#include:
+#  - name: <SomeEnabledInspectionId>
+
+#Disable inspections
+#exclude:
+#  - name: <SomeDisabledInspectionId>
+#    paths:
+#      - <path/where/not/run/inspection>
+
+projectJDK: 17 #(Applied in CI/CD pipeline)
+
+#Execute shell command before Qodana execution (Applied in CI/CD pipeline)
+#bootstrap: sh ./prepare-qodana.sh
+
+#Install IDE plugins before Qodana execution (Applied in CI/CD pipeline)
+#plugins:
+#  - id: <plugin.id> #(plugin id can be found at https://plugins.jetbrains.com)
+
+#Specify Qodana linter for analysis (Applied in CI/CD pipeline)
+linter: jetbrains/qodana-jvm:latest

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

@@ -32,6 +32,7 @@ import com.kingsrook.qqq.backend.core.logging.QLogger;
 import com.kingsrook.qqq.backend.core.utils.SleepUtils;
 import com.kingsrook.qqq.backend.core.utils.lambdas.UnsafeFunction;
 import com.kingsrook.qqq.backend.core.utils.lambdas.UnsafeSupplier;
+import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
 
 
 /*******************************************************************************
@@ -185,8 +186,7 @@ public class AsyncRecordPipeLoop
 
       if(recordCount > 0)
       {
-         LOG.info(String.format("Processed %,d records", recordCount)
-            + String.format(" at end of job [%s] in %,d ms (%.2f records/second).", jobName, (endTime - jobStartTime), 1000d * (recordCount / (.001d + (endTime - jobStartTime)))));
+         LOG.info("End of job summary", logPair("recordCount", recordCount), logPair("jobName", jobName), logPair("millis", endTime - jobStartTime), logPair("recordsPerSecond", 1000d * (recordCount / (.001d + (endTime - jobStartTime)))));
       }
 
       return (recordCount);

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

@@ -84,7 +84,7 @@ public class MetaDataAction
          }
 
          QBackendMetaData backendForTable = metaDataInput.getInstance().getBackendForTable(tableName);
-         tables.put(tableName, new QFrontendTableMetaData(backendForTable, table, false, false));
+         tables.put(tableName, new QFrontendTableMetaData(metaDataInput, backendForTable, table, false, false));
          treeNodes.put(tableName, new AppTreeNode(table));
       }
       metaDataOutput.setTables(tables);

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

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

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

@@ -65,7 +65,7 @@ public class PermissionsHelper
     *******************************************************************************/
    public static void checkTablePermissionThrowing(AbstractTableActionInput tableActionInput, TablePermissionSubType permissionSubType) throws QPermissionDeniedException
    {
-      checkTablePermissionThrowing(tableActionInput.getTableName(), permissionSubType);
+      checkTablePermissionThrowing(tableActionInput, tableActionInput.getTableName(), permissionSubType);
    }
 
 
@@ -73,7 +73,7 @@ public class PermissionsHelper
    /*******************************************************************************
     **
     *******************************************************************************/
-   private static void checkTablePermissionThrowing(String tableName, TablePermissionSubType permissionSubType) throws QPermissionDeniedException
+   private static void checkTablePermissionThrowing(AbstractActionInput actionInput, String tableName, TablePermissionSubType permissionSubType) throws QPermissionDeniedException
    {
       warnAboutPermissionSubTypeForTables(permissionSubType);
       QTableMetaData table = QContext.getQInstance().getTable(tableName);
@@ -99,11 +99,11 @@ public class PermissionsHelper
    /*******************************************************************************
     **
     *******************************************************************************/
-   public static boolean hasTablePermission(String tableName, TablePermissionSubType permissionSubType)
+   public static boolean hasTablePermission(AbstractActionInput actionInput, String tableName, TablePermissionSubType permissionSubType)
    {
       try
       {
-         checkTablePermissionThrowing(tableName, permissionSubType);
+         checkTablePermissionThrowing(actionInput, tableName, permissionSubType);
          return (true);
       }
       catch(QPermissionDeniedException e)

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

@@ -24,6 +24,7 @@ package com.kingsrook.qqq.backend.core.actions.queues;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Objects;
 import java.util.function.Supplier;
 import com.amazonaws.auth.AWSStaticCredentialsProvider;
 import com.amazonaws.auth.BasicAWSCredentials;
@@ -41,6 +42,8 @@ import com.kingsrook.qqq.backend.core.model.actions.processes.RunProcessInput;
 import com.kingsrook.qqq.backend.core.model.actions.processes.RunProcessOutput;
 import com.kingsrook.qqq.backend.core.model.metadata.QInstance;
 import com.kingsrook.qqq.backend.core.model.metadata.queues.QQueueMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.queues.SQSPollerSettings;
+import com.kingsrook.qqq.backend.core.model.metadata.queues.SQSQueueMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.queues.SQSQueueProviderMetaData;
 import com.kingsrook.qqq.backend.core.model.session.QSession;
 
@@ -90,15 +93,17 @@ public class SQSQueuePoller implements Runnable
          }
          queueUrl += queueMetaData.getQueueName();
 
-         while(true)
+         SQSPollerSettings sqsPollerSettings = getSqsPollerSettings(queueProviderMetaData, queueMetaData);
+
+         for(int loop = 0; loop < sqsPollerSettings.getMaxLoops(); loop++)
          {
             ///////////////////////////////
             // fetch a batch of messages //
             ///////////////////////////////
             ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest();
             receiveMessageRequest.setQueueUrl(queueUrl);
-            receiveMessageRequest.setMaxNumberOfMessages(10);
-            receiveMessageRequest.setWaitTimeSeconds(20); // help urge SQS to query multiple servers and find more messages
+            receiveMessageRequest.setMaxNumberOfMessages(sqsPollerSettings.getMaxNumberOfMessages());
+            receiveMessageRequest.setWaitTimeSeconds(sqsPollerSettings.getWaitTimeSeconds()); // larger value (e.g., 20) can help urge SQS to query multiple servers and find more messages
             ReceiveMessageResult receiveMessageResult = sqs.receiveMessage(receiveMessageRequest);
             if(receiveMessageResult.getMessages().isEmpty())
             {
@@ -177,6 +182,47 @@ public class SQSQueuePoller implements Runnable
 
 
 
+   /*******************************************************************************
+    ** For a given queueProvider and queue, get the poller settings to use (using
+    ** default values if none are set at either level).
+    *******************************************************************************/
+   static SQSPollerSettings getSqsPollerSettings(SQSQueueProviderMetaData queueProviderMetaData, QQueueMetaData queueMetaData)
+   {
+      /////////////////////////////////
+      // start with default settings //
+      /////////////////////////////////
+      SQSPollerSettings sqsPollerSettings = new SQSPollerSettings()
+         .withMaxLoops(Integer.MAX_VALUE)
+         .withMaxNumberOfMessages(10)
+         .withWaitTimeSeconds(20);
+
+      /////////////////////////////////////////////////////////////////////
+      // if the queue provider has settings, let them overwrite defaults //
+      /////////////////////////////////////////////////////////////////////
+      if(queueProviderMetaData != null && queueProviderMetaData.getPollerSettings() != null)
+      {
+         SQSPollerSettings providerSettings = queueProviderMetaData.getPollerSettings();
+         sqsPollerSettings.setMaxLoops(Objects.requireNonNullElse(providerSettings.getMaxLoops(), sqsPollerSettings.getMaxLoops()));
+         sqsPollerSettings.setMaxNumberOfMessages(Objects.requireNonNullElse(providerSettings.getMaxNumberOfMessages(), sqsPollerSettings.getMaxNumberOfMessages()));
+         sqsPollerSettings.setWaitTimeSeconds(Objects.requireNonNullElse(providerSettings.getWaitTimeSeconds(), sqsPollerSettings.getWaitTimeSeconds()));
+      }
+
+      ////////////////////////////////////////////////////////////
+      // if the queue has settings, let them overwrite defaults //
+      ////////////////////////////////////////////////////////////
+      if(queueMetaData instanceof SQSQueueMetaData sqsQueueMetaData && sqsQueueMetaData.getPollerSettings() != null)
+      {
+         SQSPollerSettings providerSettings = sqsQueueMetaData.getPollerSettings();
+         sqsPollerSettings.setMaxLoops(Objects.requireNonNullElse(providerSettings.getMaxLoops(), sqsPollerSettings.getMaxLoops()));
+         sqsPollerSettings.setMaxNumberOfMessages(Objects.requireNonNullElse(providerSettings.getMaxNumberOfMessages(), sqsPollerSettings.getMaxNumberOfMessages()));
+         sqsPollerSettings.setWaitTimeSeconds(Objects.requireNonNullElse(providerSettings.getWaitTimeSeconds(), sqsPollerSettings.getWaitTimeSeconds()));
+      }
+
+      return sqsPollerSettings;
+   }
+
+
+
    /*******************************************************************************
     ** Setter for queueProviderMetaData
     **

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

@@ -94,7 +94,7 @@ public class BuildScriptLogAndScriptLogLineExecutionLogger implements QCodeExecu
    protected QRecord buildDetailLogRecord(String logLine)
    {
       return (new QRecord()
-         .withValue("scriptLogId", scriptLog.getValue("id"))
+         .withValue("scriptLogId", scriptLog == null ? null : scriptLog.getValue("id"))
          .withValue("timestamp", Instant.now())
          .withValue("text", truncate(logLine)));
    }
@@ -145,6 +145,14 @@ public class BuildScriptLogAndScriptLogLineExecutionLogger implements QCodeExecu
       {
          this.executeCodeInput = executeCodeInput;
          this.scriptLog = buildHeaderRecord(executeCodeInput);
+
+         if(scriptLogLines != null)
+         {
+            for(QRecord scriptLogLine : scriptLogLines)
+            {
+               scriptLogLine.setValue("scriptLogId", scriptLog.getValue("id"));
+            }
+         }
       }
       catch(Exception e)
       {

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

@@ -22,9 +22,12 @@
 package com.kingsrook.qqq.backend.core.actions.tables;
 
 
+import java.util.Collections;
 import com.kingsrook.qqq.backend.core.actions.ActionHelper;
 import com.kingsrook.qqq.backend.core.actions.interfaces.AggregateInterface;
 import com.kingsrook.qqq.backend.core.actions.tables.helpers.QueryStatManager;
+import com.kingsrook.qqq.backend.core.actions.values.ValueBehaviorApplier;
+import com.kingsrook.qqq.backend.core.context.QContext;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
 import com.kingsrook.qqq.backend.core.logging.QLogger;
 import com.kingsrook.qqq.backend.core.model.actions.tables.aggregate.AggregateInput;
@@ -58,6 +61,11 @@ public class AggregateAction
       QTableMetaData   table   = aggregateInput.getTable();
       QBackendMetaData backend = aggregateInput.getBackend();
 
+      ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // apply any available field behaviors to the filter (noting that, if anything changes, a new filter is returned) //
+      ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      aggregateInput.setFilter(ValueBehaviorApplier.applyFieldBehaviorsToFilter(QContext.getQInstance(), table, aggregateInput.getFilter(), Collections.emptySet()));
+
       QueryStat queryStat = QueryStatManager.newQueryStat(backend, table, aggregateInput.getFilter());
 
       QBackendModuleDispatcher qBackendModuleDispatcher = new QBackendModuleDispatcher();
@@ -67,6 +75,10 @@ public class AggregateAction
       aggregateInterface.setQueryStat(queryStat);
       AggregateOutput aggregateOutput = aggregateInterface.execute(aggregateInput);
 
+      // todo, maybe, not real important? ValueBehaviorApplier.applyFieldBehaviors(ValueBehaviorApplier.Action.READ, QContext.getQInstance(), table, aggregateOutput.getResults(), null);
+      //  issue being, the signature there... it takes a list of QRecords, which aren't what we have...
+      //  do we want to ... idk, refactor all these behavior deals?  hmm... maybe a new interface/ for ones that do reads?  not sure.
+
       QueryStatManager.getInstance().add(queryStat);
 
       return aggregateOutput;

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

@@ -22,9 +22,12 @@
 package com.kingsrook.qqq.backend.core.actions.tables;
 
 
+import java.util.Collections;
 import com.kingsrook.qqq.backend.core.actions.ActionHelper;
 import com.kingsrook.qqq.backend.core.actions.interfaces.CountInterface;
 import com.kingsrook.qqq.backend.core.actions.tables.helpers.QueryStatManager;
+import com.kingsrook.qqq.backend.core.actions.values.ValueBehaviorApplier;
+import com.kingsrook.qqq.backend.core.context.QContext;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
 import com.kingsrook.qqq.backend.core.logging.QLogger;
 import com.kingsrook.qqq.backend.core.model.actions.tables.count.CountInput;
@@ -58,6 +61,11 @@ public class CountAction
       QTableMetaData   table   = countInput.getTable();
       QBackendMetaData backend = countInput.getBackend();
 
+      ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // apply any available field behaviors to the filter (noting that, if anything changes, a new filter is returned) //
+      ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      countInput.setFilter(ValueBehaviorApplier.applyFieldBehaviorsToFilter(QContext.getQInstance(), table, countInput.getFilter(), Collections.emptySet()));
+
       QueryStat queryStat = QueryStatManager.newQueryStat(backend, table, countInput.getFilter());
 
       QBackendModuleDispatcher qBackendModuleDispatcher = new QBackendModuleDispatcher();

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

@@ -23,6 +23,8 @@ package com.kingsrook.qqq.backend.core.actions.tables;
 
 
 import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
@@ -34,8 +36,10 @@ import com.kingsrook.qqq.backend.core.actions.interfaces.GetInterface;
 import com.kingsrook.qqq.backend.core.actions.tables.helpers.GetActionCacheHelper;
 import com.kingsrook.qqq.backend.core.actions.values.QPossibleValueTranslator;
 import com.kingsrook.qqq.backend.core.actions.values.QValueFormatter;
+import com.kingsrook.qqq.backend.core.actions.values.ValueBehaviorApplier;
 import com.kingsrook.qqq.backend.core.context.QContext;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
 import com.kingsrook.qqq.backend.core.model.actions.tables.get.GetInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.get.GetOutput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QCriteriaOperator;
@@ -45,11 +49,16 @@ import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryOutput;
 import com.kingsrook.qqq.backend.core.model.data.QRecord;
 import com.kingsrook.qqq.backend.core.model.metadata.fields.AdornmentType;
+import com.kingsrook.qqq.backend.core.model.metadata.fields.FieldBehavior;
+import com.kingsrook.qqq.backend.core.model.metadata.fields.FieldFilterBehavior;
 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.modules.backend.QBackendModuleDispatcher;
 import com.kingsrook.qqq.backend.core.modules.backend.QBackendModuleInterface;
+import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
 import com.kingsrook.qqq.backend.core.utils.ObjectUtils;
+import com.kingsrook.qqq.backend.core.utils.Pair;
+import com.kingsrook.qqq.backend.core.utils.memoization.Memoization;
 
 
 /*******************************************************************************
@@ -58,11 +67,15 @@ import com.kingsrook.qqq.backend.core.utils.ObjectUtils;
  *******************************************************************************/
 public class GetAction
 {
+   private static final QLogger LOG = QLogger.getLogger(GetAction.class);
+
    private Optional<TableCustomizerInterface> postGetRecordCustomizer;
 
    private GetInput                 getInput;
    private QPossibleValueTranslator qPossibleValueTranslator;
 
+   private Memoization<Pair<String, String>, List<FieldFilterBehavior<?>>> getFieldFilterBehaviorMemoization = new Memoization<>();
+
 
 
    /*******************************************************************************
@@ -105,6 +118,8 @@ public class GetAction
          usingDefaultGetInterface = true;
       }
 
+      getInput = applyFieldBehaviors(getInput);
+
       getInterface.validateInput(getInput);
       getOutput = getInterface.execute(getInput);
 
@@ -130,6 +145,82 @@ public class GetAction
 
 
 
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private GetInput applyFieldBehaviors(GetInput getInput)
+   {
+      QTableMetaData table = getInput.getTable();
+
+      try
+      {
+         if(getInput.getPrimaryKey() != null)
+         {
+            ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+            // if the input has a primary key, get its behaviors, then apply, and update the pkey in the input if the value is different //
+            ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+            List<FieldFilterBehavior<?>> fieldFilterBehaviors = getFieldFilterBehaviors(table, table.getPrimaryKeyField());
+            for(FieldFilterBehavior<?> fieldFilterBehavior : CollectionUtils.nonNullList(fieldFilterBehaviors))
+            {
+               QFilterCriteria pkeyCriteria    = new QFilterCriteria(table.getPrimaryKeyField(), QCriteriaOperator.EQUALS, getInput.getPrimaryKey());
+               QFilterCriteria updatedCriteria = ValueBehaviorApplier.apply(pkeyCriteria, QContext.getQInstance(), table, table.getField(table.getPrimaryKeyField()), fieldFilterBehavior);
+               if(updatedCriteria != pkeyCriteria)
+               {
+                  getInput.setPrimaryKey(updatedCriteria.getValues().get(0));
+               }
+            }
+         }
+         else if(getInput.getUniqueKey() != null)
+         {
+            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+            // if the input has a unique key, get its behaviors, then apply, and update the ukey values in the input if any are different //
+            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+            Map<String, Serializable> updatedUniqueKey = new HashMap<>(getInput.getUniqueKey());
+            for(String fieldName : getInput.getUniqueKey().keySet())
+            {
+               List<FieldFilterBehavior<?>> fieldFilterBehaviors = getFieldFilterBehaviors(table, fieldName);
+               for(FieldFilterBehavior<?> fieldFilterBehavior : CollectionUtils.nonNullList(fieldFilterBehaviors))
+               {
+                  QFilterCriteria ukeyCriteria    = new QFilterCriteria(fieldName, QCriteriaOperator.EQUALS, updatedUniqueKey.get(fieldName));
+                  QFilterCriteria updatedCriteria = ValueBehaviorApplier.apply(ukeyCriteria, QContext.getQInstance(), table, table.getField(table.getPrimaryKeyField()), fieldFilterBehavior);
+                  updatedUniqueKey.put(fieldName, updatedCriteria.getValues().get(0));
+               }
+            }
+            getInput.setUniqueKey(updatedUniqueKey);
+         }
+      }
+      catch(Exception e)
+      {
+         LOG.warn("Error applying field behaviors to get input - will run with original inputs", e);
+      }
+
+      return (getInput);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private List<FieldFilterBehavior<?>> getFieldFilterBehaviors(QTableMetaData tableMetaData, String fieldName)
+   {
+      Pair<String, String> key = new Pair<>(tableMetaData.getName(), fieldName);
+      return getFieldFilterBehaviorMemoization.getResult(key, (p) ->
+      {
+         List<FieldFilterBehavior<?>> rs = new ArrayList<>();
+         for(FieldBehavior<?> fieldBehavior : CollectionUtils.nonNullCollection(tableMetaData.getFields().get(fieldName).getBehaviors()))
+         {
+            if(fieldBehavior instanceof FieldFilterBehavior<?> fieldFilterBehavior)
+            {
+               rs.add(fieldFilterBehavior);
+            }
+         }
+         return (rs);
+      }).orElse(null);
+   }
+
+
+
    /*******************************************************************************
     ** shorthand way to call for the most common use-case, when you just want the
     ** output record to be returned.
@@ -255,6 +346,8 @@ public class GetAction
          returnRecord = postGetRecordCustomizer.get().postQuery(getInput, List.of(record)).get(0);
       }
 
+      ValueBehaviorApplier.applyFieldBehaviors(ValueBehaviorApplier.Action.READ, QContext.getQInstance(), getInput.getTable(), List.of(record), null);
+
       if(getInput.getShouldTranslatePossibleValues())
       {
          if(qPossibleValueTranslator == null)

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

@@ -25,6 +25,7 @@ package com.kingsrook.qqq.backend.core.actions.tables;
 import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
@@ -41,6 +42,7 @@ import com.kingsrook.qqq.backend.core.actions.tables.helpers.QueryActionCacheHel
 import com.kingsrook.qqq.backend.core.actions.tables.helpers.QueryStatManager;
 import com.kingsrook.qqq.backend.core.actions.values.QPossibleValueTranslator;
 import com.kingsrook.qqq.backend.core.actions.values.QValueFormatter;
+import com.kingsrook.qqq.backend.core.actions.values.ValueBehaviorApplier;
 import com.kingsrook.qqq.backend.core.context.QContext;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
 import com.kingsrook.qqq.backend.core.logging.QLogger;
@@ -117,6 +119,11 @@ public class QueryAction
          }
       }
 
+      ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // apply any available field behaviors to the filter (noting that, if anything changes, a new filter is returned) //
+      ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      queryInput.setFilter(ValueBehaviorApplier.applyFieldBehaviorsToFilter(QContext.getQInstance(), table, queryInput.getFilter(), Collections.emptySet()));
+
       QueryStat queryStat = QueryStatManager.newQueryStat(backend, table, queryInput.getFilter());
 
       QBackendModuleDispatcher qBackendModuleDispatcher = new QBackendModuleDispatcher();
@@ -284,6 +291,8 @@ public class QueryAction
          records = postQueryRecordCustomizer.get().postQuery(queryInput, records);
       }
 
+      ValueBehaviorApplier.applyFieldBehaviors(ValueBehaviorApplier.Action.READ, QContext.getQInstance(), queryInput.getTable(), records, null);
+
       if(queryInput.getShouldTranslatePossibleValues())
       {
          if(qPossibleValueTranslator == null)

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

@@ -22,12 +22,18 @@
 package com.kingsrook.qqq.backend.core.actions.values;
 
 
+import java.io.Serializable;
+import java.util.ArrayList;
 import java.util.List;
+import java.util.Objects;
 import java.util.Set;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QFilterCriteria;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QQueryFilter;
 import com.kingsrook.qqq.backend.core.model.data.QRecord;
 import com.kingsrook.qqq.backend.core.model.metadata.QInstance;
 import com.kingsrook.qqq.backend.core.model.metadata.fields.FieldBehavior;
 import com.kingsrook.qqq.backend.core.model.metadata.fields.FieldDisplayBehavior;
+import com.kingsrook.qqq.backend.core.model.metadata.fields.FieldFilterBehavior;
 import com.kingsrook.qqq.backend.core.model.metadata.fields.QFieldMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
 import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
@@ -46,6 +52,7 @@ public class ValueBehaviorApplier
    {
       INSERT,
       UPDATE,
+      READ,
       FORMATTING
    }
 
@@ -97,4 +104,169 @@ public class ValueBehaviorApplier
       }
    }
 
+
+
+   /*******************************************************************************
+    ** apply field behaviors (of FieldFilterBehavior type) to a QQueryFilter.
+    ** note that, we don't like to ever edit a QQueryFilter itself (e.g., as it might
+    ** have come from meta-data, or it might have some immutable structures in it).
+    ** So, if any changes are needed, they'll be returned in a clone.
+    ** So, either way, you should use this method like:
+    *
+    ** QQueryFilter myFilter = // wherever I got my filter from
+    ** myFilter = ValueBehaviorApplier.applyFieldBehaviorsToFilter(QContext.getInstance, table, myFilter, null);
+    ** // e.g., always re-assign over top of your filter.
+    *******************************************************************************/
+   public static QQueryFilter applyFieldBehaviorsToFilter(QInstance instance, QTableMetaData table, QQueryFilter filter, Set<FieldBehavior<?>> behaviorsToOmit)
+   {
+      ////////////////////////////////////////////////
+      // for null or empty filter, return the input //
+      ////////////////////////////////////////////////
+      if(filter == null || !filter.hasAnyCriteria())
+      {
+         return (filter);
+      }
+
+      ///////////////////////////////////////////////////////////////////
+      // track if we need to make & return a clone.                    //
+      // which will be the case if we get back any different criteria, //
+      // or any different sub-filters, than what we originally had.    //
+      ///////////////////////////////////////////////////////////////////
+      boolean needToUseClone = false;
+
+      ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // make a new criteria list, and a new subFilter list - either null, if the source was null, or a new array list //
+      ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      List<QFilterCriteria> newCriteriaList = filter.getCriteria() == null ? null : new ArrayList<>();
+      List<QQueryFilter>    newSubFilters   = filter.getSubFilters() == null ? null : new ArrayList<>();
+
+      //////////////////////////////////////////////////////////////////////////////
+      // for each criteria, if its field has any applicable behaviors, apply them //
+      //////////////////////////////////////////////////////////////////////////////
+      for(QFilterCriteria criteria : CollectionUtils.nonNullList(filter.getCriteria()))
+      {
+         QFieldMetaData field = table.getFields().get(criteria.getFieldName());
+         if(field == null && criteria.getFieldName() != null && criteria.getFieldName().contains("."))
+         {
+            String[] parts = criteria.getFieldName().split("\\.");
+            if(parts.length == 2)
+            {
+               QTableMetaData joinTable = instance.getTable(parts[0]);
+               if(joinTable != null)
+               {
+                  field = joinTable.getFields().get(parts[1]);
+               }
+            }
+         }
+
+         QFilterCriteria criteriaToUse = criteria;
+         if(field != null)
+         {
+            for(FieldBehavior<?> fieldBehavior : CollectionUtils.nonNullCollection(field.getBehaviors()))
+            {
+               boolean applyBehavior = true;
+               if(behaviorsToOmit != null && behaviorsToOmit.contains(fieldBehavior))
+               {
+                  applyBehavior = false;
+               }
+
+               if(applyBehavior && fieldBehavior instanceof FieldFilterBehavior<?> filterBehavior)
+               {
+                  //////////////////////////////////////////////////////////////////////
+                  // call to apply the behavior on the criteria - which will return a //
+                  // new criteria if any values are changed, else the input criteria  //
+                  //////////////////////////////////////////////////////////////////////
+                  criteriaToUse = apply(criteriaToUse, instance, table, field, filterBehavior);
+
+                  ////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                  // if the new criteria is not the same as the old criteria, mark that we need to make and return a clone. //
+                  ////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                  if(criteriaToUse != criteria)
+                  {
+                     needToUseClone = true;
+                  }
+               }
+            }
+         }
+
+         newCriteriaList.add(criteriaToUse);
+      }
+
+      /////////////////////////////////////////////////////////////////////////////////////////////////
+      // similar to above - iterate over the subfilters, making a recursive call, and tracking if we //
+      // got back the same object (in which case, there are no changes, and we don't need to clone), //
+      // or a different object (in which case, we do need a clone, because there were changes).      //
+      /////////////////////////////////////////////////////////////////////////////////////////////////
+      for(QQueryFilter subFilter : CollectionUtils.nonNullList(filter.getSubFilters()))
+      {
+         QQueryFilter newSubFilter = applyFieldBehaviorsToFilter(instance, table, subFilter, behaviorsToOmit);
+         if(newSubFilter != subFilter)
+         {
+            newSubFilters.add(newSubFilter);
+            needToUseClone = true;
+         }
+         else
+         {
+            newSubFilters.add(subFilter);
+         }
+      }
+
+      //////////////////////////////////////////////////////////////////////////////////////////////////
+      // if we need to return a clone, then do so, replacing the lists with the ones we built in here //
+      //////////////////////////////////////////////////////////////////////////////////////////////////
+      if(needToUseClone)
+      {
+         QQueryFilter cloneFilter = filter.clone();
+         cloneFilter.setCriteria(newCriteriaList);
+         cloneFilter.setSubFilters(newSubFilters);
+         return (cloneFilter);
+      }
+
+      /////////////////////////////////////////////////////////////////////////////
+      // else, if no clone needed (e.g., no changes), return the original filter //
+      /////////////////////////////////////////////////////////////////////////////
+      return (filter);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public static QFilterCriteria apply(QFilterCriteria criteria, QInstance instance, QTableMetaData table, QFieldMetaData field, FieldFilterBehavior<?> filterBehavior)
+   {
+      if(criteria == null || CollectionUtils.nullSafeIsEmpty(criteria.getValues()))
+      {
+         return (criteria);
+      }
+
+      List<Serializable> newValues  = new ArrayList<>();
+      boolean            changedAny = false;
+
+      for(Serializable value : criteria.getValues())
+      {
+         Serializable newValue = filterBehavior.applyToFilterCriteriaValue(value, instance, table, field);
+         if(!Objects.equals(value, newValue))
+         {
+            newValues.add(newValue);
+            changedAny = true;
+         }
+         else
+         {
+            newValues.add(value);
+         }
+      }
+
+      if(changedAny)
+      {
+         QFilterCriteria clone = criteria.clone();
+         clone.setValues(newValues);
+         return (clone);
+      }
+      else
+      {
+         return (criteria);
+      }
+   }
+
 }

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

@@ -123,6 +123,18 @@ public class QInstanceEnricher
     *******************************************************************************/
    public void enrich()
    {
+      /////////////////////////////////////////////////////////////////////////////////////////
+      // at one point, we did apps later - but - it was possible to put tables in an app's   //
+      // sections, but not its children list (enrichApp fixes this by adding such tables to  //
+      // the children list) so then when enrichTable runs, it looks for fields that are      //
+      // possible-values pointed at tables,  for adding LINK adornments - and that could     //
+      // cause such links to be omitted, mysteriously!  so, do app enrichment before tables. //
+      /////////////////////////////////////////////////////////////////////////////////////////
+      if(qInstance.getApps() != null)
+      {
+         qInstance.getApps().values().forEach(this::enrichApp);
+      }
+
       if(qInstance.getTables() != null)
       {
          qInstance.getTables().values().forEach(this::enrichTable);
@@ -139,11 +151,6 @@ public class QInstanceEnricher
          qInstance.getBackends().values().forEach(this::enrichBackend);
       }
 
-      if(qInstance.getApps() != null)
-      {
-         qInstance.getApps().values().forEach(this::enrichApp);
-      }
-
       if(qInstance.getReports() != null)
       {
          qInstance.getReports().values().forEach(this::enrichReport);

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

@@ -0,0 +1,34 @@
+/*
+ * 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.instances;
+
+
+/*******************************************************************************
+ ** Object used to record state of a QInstance having been validated.
+ **
+ *******************************************************************************/
+public enum QInstanceValidationState
+{
+   PENDING,
+   RUNNING,
+   COMPLETE
+}

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

@@ -79,6 +79,8 @@ import com.kingsrook.qqq.backend.core.model.metadata.processes.QStepMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.processes.QSupplementalProcessMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.queues.QQueueMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.queues.QQueueProviderMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.queues.QueueType;
+import com.kingsrook.qqq.backend.core.model.metadata.queues.SQSQueueMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.queues.SQSQueueProviderMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.reporting.QReportDataSource;
 import com.kingsrook.qqq.backend.core.model.metadata.reporting.QReportField;
@@ -139,14 +141,20 @@ public class QInstanceValidator
     *******************************************************************************/
    public void validate(QInstance qInstance) throws QInstanceValidationException
    {
-      if(qInstance.getHasBeenValidated())
+      if(qInstance.getHasBeenValidated() || qInstance.getValidationIsRunning())
       {
-         //////////////////////////////////////////
-         // don't re-validate if previously done //
-         //////////////////////////////////////////
+         ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+         // don't re-validate if previously complete or currently running (avoids recursive re-validation chaos!) //
+         ///////////////////////////////////////////////////////////////////////////////////////////////////////////
          return;
       }
 
+      ////////////////////////////////////
+      // mark validation as running now //
+      ////////////////////////////////////
+      QInstanceValidationKey validationKey = new QInstanceValidationKey();
+      qInstance.setValidationIsRunning(validationKey);
+
       /////////////////////////////////////////////////////////////////////////////////////////////////////
       // the enricher will build a join graph (if there are any joins).  we'd like to only do that       //
       // once, during the enrichment/validation work, so, capture it, and store it back in the instance. //
@@ -207,9 +215,11 @@ public class QInstanceValidator
          throw (new QInstanceValidationException(errors));
       }
 
-      QInstanceValidationKey validationKey = new QInstanceValidationKey();
-      qInstance.setHasBeenValidated(validationKey);
+      //////////////////////////////
+      // mark validation complete //
+      //////////////////////////////
       qInstance.setJoinGraph(validationKey, joinGraph);
+      qInstance.setHasBeenValidated(validationKey);
    }
 
 
@@ -431,11 +441,30 @@ public class QInstanceValidator
 
             if(queueProvider instanceof SQSQueueProviderMetaData sqsQueueProvider)
             {
+               if(queueProvider.getType() != null)
+               {
+                  assertCondition(queueProvider.getType().equals(QueueType.SQS), "Inconsistent Type/class given for queueProvider: " + name + " (SQSQueueProviderMetaData is not allowed for type " + queueProvider.getType() + ")");
+               }
+
                assertCondition(StringUtils.hasContent(sqsQueueProvider.getAccessKey()), "Missing accessKey for SQSQueueProvider: " + name);
                assertCondition(StringUtils.hasContent(sqsQueueProvider.getSecretKey()), "Missing secretKey for SQSQueueProvider: " + name);
                assertCondition(StringUtils.hasContent(sqsQueueProvider.getBaseURL()), "Missing baseURL for SQSQueueProvider: " + name);
                assertCondition(StringUtils.hasContent(sqsQueueProvider.getRegion()), "Missing region for SQSQueueProvider: " + name);
             }
+            else if(queueProvider.getClass().equals(QQueueProviderMetaData.class))
+            {
+               /////////////////////////////////////////////////////////////////////
+               // this just means a subtype wasn't used, so, it should be allowed //
+               // (unless we had a case where a type required a subtype?)         //
+               /////////////////////////////////////////////////////////////////////
+            }
+            else
+            {
+               if(queueProvider.getType() != null)
+               {
+                  assertCondition(!queueProvider.getType().equals(QueueType.SQS), "Inconsistent Type/class given for queueProvider: " + name + " (" + queueProvider.getClass().getSimpleName() + " is not allowed for type " + queueProvider.getType() + ")");
+               }
+            }
 
             runPlugins(QQueueProviderMetaData.class, queueProvider, qInstance);
          });
@@ -446,7 +475,27 @@ public class QInstanceValidator
          qInstance.getQueues().forEach((name, queue) ->
          {
             assertCondition(Objects.equals(name, queue.getName()), "Inconsistent naming for queue: " + name + "/" + queue.getName() + ".");
-            assertCondition(qInstance.getQueueProvider(queue.getProviderName()) != null, "Unrecognized queue providerName for queue: " + name);
+
+            QQueueProviderMetaData queueProvider = qInstance.getQueueProvider(queue.getProviderName());
+            if(assertCondition(queueProvider != null, "Unrecognized queue providerName for queue: " + name))
+            {
+               if(queue instanceof SQSQueueMetaData)
+               {
+                  assertCondition(queueProvider.getType().equals(QueueType.SQS), "Inconsistent class given for queueMetaData: " + name + " (SQSQueueMetaData is not allowed for queue provider of type " + queueProvider.getType() + ")");
+               }
+               else if(queue.getClass().equals(QQueueMetaData.class))
+               {
+                  ////////////////////////////////////////////////////////////////////
+                  // this just means a subtype wasn't used, so, it should be        //
+                  // allowed (unless we had a case where a type required a subtype? //
+                  ////////////////////////////////////////////////////////////////////
+               }
+               else
+               {
+                  assertCondition(!queueProvider.getType().equals(QueueType.SQS), "Inconsistent class given for queueProvider: " + name + " (" + queue.getClass().getSimpleName() + " is not allowed for type " + queueProvider.getType() + ")");
+               }
+            }
+
             assertCondition(StringUtils.hasContent(queue.getQueueName()), "Missing queueName for queue: " + name);
             if(assertCondition(StringUtils.hasContent(queue.getProcessName()), "Missing processName for queue: " + name))
             {
@@ -933,7 +982,7 @@ public class QInstanceValidator
          }
 
          assertCondition(fieldSecurityLock.getDefaultBehavior() != null, prefix + "has a fieldSecurityLock that is missing a defaultBehavior");
-         assertCondition(CollectionUtils.nullSafeHasContents(fieldSecurityLock.getKeyValueBehaviors()), prefix + "has a fieldSecurityLock that is missing keyValueBehaviors");
+         assertCondition(CollectionUtils.nullSafeHasContents(fieldSecurityLock.getOverrideValues()), prefix + "has a fieldSecurityLock that is missing overrideValues");
       }
 
       for(FieldAdornment adornment : CollectionUtils.nonNullList(field.getAdornments()))

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

@@ -107,8 +107,10 @@ public class AbstractActionInput
    /*******************************************************************************
     ** Getter for instance
     **
+    ** Deprecated.  Please use QContext.getInstance() instead
     *******************************************************************************/
    @JsonIgnore
+   @Deprecated
    public QInstance getInstance()
    {
       return (QContext.getQInstance());
@@ -119,8 +121,10 @@ public class AbstractActionInput
    /*******************************************************************************
     ** Getter for session
     **
+    ** Deprecated.  Please use QContext.getSession() instead
     *******************************************************************************/
    @JsonIgnore
+   @Deprecated
    public QSession getSession()
    {
       return (QContext.getQSession());

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

@@ -53,7 +53,7 @@ public class QueryOutput extends AbstractActionOutput implements Serializable
       }
       else
       {
-         storage = new QueryOutputList();
+         storage = new QueryOutputList(queryInput);
       }
    }
 

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

@@ -24,7 +24,10 @@ package com.kingsrook.qqq.backend.core.model.actions.tables.query;
 
 import java.util.ArrayList;
 import java.util.List;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
 import com.kingsrook.qqq.backend.core.model.data.QRecord;
+import org.apache.logging.log4j.Level;
+import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
 
 
 /*******************************************************************************
@@ -33,15 +36,50 @@ import com.kingsrook.qqq.backend.core.model.data.QRecord;
  *******************************************************************************/
 class QueryOutputList implements QueryOutputStorageInterface
 {
-   private List<QRecord> records = new ArrayList<>();
+   private static final QLogger LOG = QLogger.getLogger(QueryOutputList.class);
+
+   private final String        tableName;
+   private       List<QRecord> records = new ArrayList<>();
+
+   private static int LOG_SIZE_INFO_OVER  = 50_000;
+   private static int LOG_SIZE_WARN_OVER  = 100_000;
+   private static int LOG_SIZE_ERROR_OVER = 250_000;
 
 
 
    /*******************************************************************************
     **
     *******************************************************************************/
-   public QueryOutputList()
+   public QueryOutputList(QueryInput queryInput)
    {
+      tableName = queryInput.getTableName();
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private void logSize(int sizeBefore, int sizeAfter)
+   {
+      Level level = null;
+      if(sizeBefore < LOG_SIZE_ERROR_OVER && sizeAfter >= LOG_SIZE_ERROR_OVER)
+      {
+         level = Level.ERROR;
+      }
+      else if(sizeBefore < LOG_SIZE_WARN_OVER && sizeAfter >= LOG_SIZE_WARN_OVER)
+      {
+         level = Level.WARN;
+      }
+      else if(sizeBefore < LOG_SIZE_INFO_OVER && sizeAfter >= LOG_SIZE_INFO_OVER)
+      {
+         level = Level.INFO;
+      }
+
+      if(level != null)
+      {
+         LOG.log(level, "Large number of records in QueryOutputList", new Throwable(), logPair("noRecords", sizeAfter), logPair("tableName", tableName));
+      }
    }
 
 
@@ -52,7 +90,9 @@ class QueryOutputList implements QueryOutputStorageInterface
    @Override
    public void addRecord(QRecord record)
    {
+      int sizeBefore = this.records.size();
       records.add(record);
+      logSize(sizeBefore, this.records.size());
    }
 
 
@@ -63,7 +103,9 @@ class QueryOutputList implements QueryOutputStorageInterface
    @Override
    public void addRecords(List<QRecord> records)
    {
+      int sizeBefore = this.records.size();
       this.records.addAll(records);
+      logSize(sizeBefore, this.records.size());
    }
 
 
@@ -77,4 +119,36 @@ class QueryOutputList implements QueryOutputStorageInterface
       return (records);
    }
 
+
+
+   /*******************************************************************************
+    ** Setter for LOG_SIZE_INFO_OVER
+    **
+    *******************************************************************************/
+   public static void setLogSizeInfoOver(int logSizeInfoOver)
+   {
+      QueryOutputList.LOG_SIZE_INFO_OVER = logSizeInfoOver;
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for LOG_SIZE_WARN_OVER
+    **
+    *******************************************************************************/
+   public static void setLogSizeWarnOver(int logSizeWarnOver)
+   {
+      QueryOutputList.LOG_SIZE_WARN_OVER = logSizeWarnOver;
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for LOG_SIZE_ERROR_OVER
+    **
+    *******************************************************************************/
+   public static void setLogSizeErrorOver(int logSizeErrorOver)
+   {
+      QueryOutputList.LOG_SIZE_ERROR_OVER = logSizeErrorOver;
+   }
 }

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

@@ -35,6 +35,7 @@ import com.kingsrook.qqq.backend.core.actions.metadata.MetaDataAction;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
 import com.kingsrook.qqq.backend.core.instances.QInstanceHelpContentManager;
 import com.kingsrook.qqq.backend.core.instances.QInstanceValidationKey;
+import com.kingsrook.qqq.backend.core.instances.QInstanceValidationState;
 import com.kingsrook.qqq.backend.core.model.actions.AbstractActionInput;
 import com.kingsrook.qqq.backend.core.model.actions.metadata.MetaDataInput;
 import com.kingsrook.qqq.backend.core.model.actions.metadata.MetaDataOutput;
@@ -112,10 +113,13 @@ public class QInstance
    private QPermissionRules defaultPermissionRules = QPermissionRules.defaultInstance();
    private QAuditRules      defaultAuditRules      = QAuditRules.defaultInstanceLevelNone();
 
-   // todo - lock down the object (no more changes allowed) after it's been validated?
+   //////////////////////////////////////////////////////////////////////////////////////
+   // todo - lock down the object (no more changes allowed) after it's been validated? //
+   //  if doing so, may need to copy all of the collections into read-only versions... //
+   //////////////////////////////////////////////////////////////////////////////////////
 
    @JsonIgnore
-   private boolean hasBeenValidated = false;
+   private QInstanceValidationState validationState = QInstanceValidationState.PENDING;
 
    private Map<String, String> memoizedTablePaths   = new HashMap<>();
    private Map<String, String> memoizedProcessPaths = new HashMap<>();
@@ -799,32 +803,58 @@ public class QInstance
     *******************************************************************************/
    public boolean getHasBeenValidated()
    {
-      return hasBeenValidated;
+      return validationState.equals(QInstanceValidationState.COMPLETE);
    }
 
 
 
    /*******************************************************************************
     ** If pass a QInstanceValidationKey (which can only be instantiated by the validator),
-    ** then the hasBeenValidated field will be set to true.
+    ** then the validationState will be set to COMPLETE.
     **
-    ** Else, if passed a null, hasBeenValidated will be reset to false - e.g., to
+    ** Else, if passed a null, the validationState will be reset to PENDING.  e.g., to
     ** re-trigger validation (can be useful in tests).
     *******************************************************************************/
    public void setHasBeenValidated(QInstanceValidationKey key)
    {
       if(key == null)
       {
-         this.hasBeenValidated = false;
+         this.validationState = QInstanceValidationState.PENDING;
       }
       else
       {
-         this.hasBeenValidated = true;
+         this.validationState = QInstanceValidationState.COMPLETE;
       }
    }
 
 
 
+   /*******************************************************************************
+    ** If pass a QInstanceValidationKey (which can only be instantiated by the validator),
+    ** then the validationState set to RUNNING.
+    **
+    *******************************************************************************/
+   public void setValidationIsRunning(QInstanceValidationKey key)
+   {
+      if(key != null)
+      {
+         this.validationState = QInstanceValidationState.RUNNING;
+      }
+   }
+
+
+
+   /*******************************************************************************
+    ** check if the instance is currently running validation.
+    **
+    *******************************************************************************/
+   public boolean getValidationIsRunning()
+   {
+      return validationState.equals(QInstanceValidationState.RUNNING);
+   }
+
+
+
    /*******************************************************************************
     ** Getter for branding
     **

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

@@ -0,0 +1,172 @@
+/*
+ * 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.fields;
+
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+import java.util.function.Function;
+import com.kingsrook.qqq.backend.core.actions.values.ValueBehaviorApplier;
+import com.kingsrook.qqq.backend.core.model.data.QRecord;
+import com.kingsrook.qqq.backend.core.model.metadata.QInstance;
+import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
+import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
+
+
+/*******************************************************************************
+ ** Field behavior that changes the case of string values.
+ *******************************************************************************/
+public enum CaseChangeBehavior implements FieldBehavior<CaseChangeBehavior>, FieldBehaviorForFrontend, FieldFilterBehavior<CaseChangeBehavior>
+{
+   NONE(null),
+   TO_UPPER_CASE((String s) -> s.toUpperCase()),
+   TO_LOWER_CASE((String s) -> s.toLowerCase());
+
+
+   private final Function<String, String> function;
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   CaseChangeBehavior(Function<String, String> function)
+   {
+      this.function = function;
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Override
+   public CaseChangeBehavior getDefault()
+   {
+      return (NONE);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Override
+   public void apply(ValueBehaviorApplier.Action action, List<QRecord> recordList, QInstance instance, QTableMetaData table, QFieldMetaData field)
+   {
+      if(this.equals(NONE))
+      {
+         return;
+      }
+
+      switch(this)
+      {
+         case TO_UPPER_CASE, TO_LOWER_CASE -> applyFunction(recordList, table, field);
+         default -> throw new IllegalStateException("Unexpected enum value: " + this);
+      }
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private void applyFunction(List<QRecord> recordList, QTableMetaData table, QFieldMetaData field)
+   {
+      String fieldName = field.getName();
+      for(QRecord record : CollectionUtils.nonNullList(recordList))
+      {
+         String value = record.getValueString(fieldName);
+         if(value != null && function != null)
+         {
+            record.setValue(fieldName, function.apply(value));
+         }
+      }
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Override
+   public Serializable applyToFilterCriteriaValue(Serializable value, QInstance instance, QTableMetaData table, QFieldMetaData field)
+   {
+      if(this.equals(NONE) || function == null)
+      {
+         return (value);
+      }
+
+      if(value instanceof String s)
+      {
+         String newValue = function.apply(s);
+         if(!Objects.equals(value, newValue))
+         {
+            return (newValue);
+         }
+      }
+
+      return (value);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Override
+   public boolean allowMultipleBehaviorsOfThisType()
+   {
+      return (false);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Override
+   public List<String> validateBehaviorConfiguration(QTableMetaData tableMetaData, QFieldMetaData fieldMetaData)
+   {
+      if(this == NONE)
+      {
+         return Collections.emptyList();
+      }
+
+      List<String> errors      = new ArrayList<>();
+      String       errorSuffix = " field [" + fieldMetaData.getName() + "] in table [" + tableMetaData.getName() + "]";
+
+      if(fieldMetaData.getType() != null)
+      {
+         if(!fieldMetaData.getType().isStringLike())
+         {
+            errors.add("A CaseChange was a applied to a non-String-like field:" + errorSuffix);
+         }
+      }
+
+      return (errors);
+   }
+
+}

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

@@ -0,0 +1,34 @@
+/*
+ * 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.fields;
+
+
+import java.io.Serializable;
+
+
+/*******************************************************************************
+ ** Marker interface for a field behavior which you might want to send to a
+ ** frontend (e.g., so it can edit values to match what'll happen in the backend).
+ *******************************************************************************/
+public interface FieldBehaviorForFrontend extends Serializable
+{
+}

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

@@ -23,7 +23,8 @@ package com.kingsrook.qqq.backend.core.model.metadata.fields;
 
 
 /*******************************************************************************
- **
+ ** Interface to mark a field behavior as one to be used during generating
+ ** display values.
  *******************************************************************************/
 public interface FieldDisplayBehavior<T extends FieldDisplayBehavior<T>> extends FieldBehavior<T>
 {

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

@@ -0,0 +1,43 @@
+/*
+ * 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.fields;
+
+
+import java.io.Serializable;
+import com.kingsrook.qqq.backend.core.model.metadata.QInstance;
+import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
+
+
+/*******************************************************************************
+ ** Interface to mark a field behavior as one to be used before a query filter
+ ** is executed.
+ *******************************************************************************/
+public interface FieldFilterBehavior<T extends FieldFilterBehavior<T>> extends FieldBehavior<T>
+{
+
+   /*******************************************************************************
+    ** Apply the filter to a value from a criteria.
+    ** If you don't want to change the input value, return the parameter.
+    *******************************************************************************/
+   Serializable applyToFilterCriteriaValue(Serializable value, QInstance instance, QTableMetaData table, QFieldMetaData field);
+
+}

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

@@ -23,13 +23,17 @@ package com.kingsrook.qqq.backend.core.model.metadata.frontend;
 
 
 import java.io.Serializable;
+import java.util.ArrayList;
 import java.util.List;
 import com.fasterxml.jackson.annotation.JsonInclude;
 import com.fasterxml.jackson.annotation.JsonInclude.Include;
 import com.kingsrook.qqq.backend.core.model.metadata.fields.FieldAdornment;
+import com.kingsrook.qqq.backend.core.model.metadata.fields.FieldBehavior;
+import com.kingsrook.qqq.backend.core.model.metadata.fields.FieldBehaviorForFrontend;
 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.help.QHelpContent;
+import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
 
 
 /*******************************************************************************
@@ -53,6 +57,8 @@ public class QFrontendFieldMetaData
    private List<FieldAdornment> adornments;
    private List<QHelpContent>   helpContents;
 
+   private List<FieldBehaviorForFrontend> behaviors;
+
    //////////////////////////////////////////////////////////////////////////////////
    // do not add setters.  take values from the source-object in the constructor!! //
    //////////////////////////////////////////////////////////////////////////////////
@@ -75,6 +81,18 @@ public class QFrontendFieldMetaData
       this.adornments = fieldMetaData.getAdornments();
       this.defaultValue = fieldMetaData.getDefaultValue();
       this.helpContents = fieldMetaData.getHelpContents();
+
+      for(FieldBehavior<?> behavior : CollectionUtils.nonNullCollection(fieldMetaData.getBehaviors()))
+      {
+         if(behavior instanceof FieldBehaviorForFrontend fbff)
+         {
+            if(behaviors == null)
+            {
+               behaviors = new ArrayList<>();
+            }
+            behaviors.add(fbff);
+         }
+      }
    }
 
 
@@ -198,4 +216,14 @@ public class QFrontendFieldMetaData
       return helpContents;
    }
 
+
+
+   /*******************************************************************************
+    ** Getter for fieldBehaviors
+    **
+    *******************************************************************************/
+   public List<FieldBehaviorForFrontend> getBehaviors()
+   {
+      return behaviors;
+   }
 }

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

@@ -35,18 +35,17 @@ import com.fasterxml.jackson.annotation.JsonInclude.Include;
 import com.kingsrook.qqq.backend.core.actions.permissions.PermissionsHelper;
 import com.kingsrook.qqq.backend.core.actions.permissions.TablePermissionSubType;
 import com.kingsrook.qqq.backend.core.context.QContext;
+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.help.QHelpContent;
-import com.kingsrook.qqq.backend.core.model.metadata.security.FieldSecurityLock;
 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;
 import com.kingsrook.qqq.backend.core.model.metadata.tables.QSupplementalTableMetaData;
 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;
 
 
@@ -90,14 +89,12 @@ public class QFrontendTableMetaData
    /*******************************************************************************
     **
     *******************************************************************************/
-   public QFrontendTableMetaData(QBackendMetaData backendForTable, QTableMetaData tableMetaData, boolean includeFullMetaData, boolean includeJoins)
+   public QFrontendTableMetaData(AbstractActionInput actionInput, QBackendMetaData backendForTable, QTableMetaData tableMetaData, boolean includeFullMetaData, boolean includeJoins)
    {
       this.name = tableMetaData.getName();
       this.label = tableMetaData.getLabel();
       this.isHidden = tableMetaData.getIsHidden();
 
-      QSession qSession = QContext.getQSession();
-
       if(includeFullMetaData)
       {
          this.primaryKeyField = tableMetaData.getPrimaryKeyField();
@@ -105,21 +102,7 @@ public class QFrontendTableMetaData
          for(String fieldName : tableMetaData.getFields().keySet())
          {
             QFieldMetaData field = tableMetaData.getField(fieldName);
-
-            ////////////////////////////////////////////////////////
-            // apply field security lock behaviors, if applicable //
-            ////////////////////////////////////////////////////////
-            boolean isDenied = false;
-            if(field.getFieldSecurityLock() != null)
-            {
-               FieldSecurityLock.Behavior behavior = field.getFieldSecurityLock().getBehaviorForSession(qSession);
-               if(FieldSecurityLock.Behavior.DENY.equals(behavior))
-               {
-                  isDenied = true;
-               }
-            }
-
-            if(!field.getIsHidden() && !isDenied)
+            if(!field.getIsHidden())
             {
                this.fields.put(fieldName, new QFrontendFieldMetaData(field));
             }
@@ -143,7 +126,7 @@ public class QFrontendTableMetaData
             QTableMetaData joinTable = qInstance.getTable(exposedJoin.getJoinTable());
             frontendExposedJoin.setLabel(exposedJoin.getLabel());
             frontendExposedJoin.setIsMany(exposedJoin.getIsMany());
-            frontendExposedJoin.setJoinTable(new QFrontendTableMetaData(backendForTable, joinTable, includeFullMetaData, false));
+            frontendExposedJoin.setJoinTable(new QFrontendTableMetaData(actionInput, backendForTable, joinTable, includeFullMetaData, false));
             for(String joinName : exposedJoin.getJoinPath())
             {
                frontendExposedJoin.addJoin(qInstance.getJoin(joinName));
@@ -180,16 +163,16 @@ public class QFrontendTableMetaData
 
       setCapabilities(backendForTable, tableMetaData);
 
-      readPermission = PermissionsHelper.hasTablePermission(tableMetaData.getName(), TablePermissionSubType.READ);
-      insertPermission = PermissionsHelper.hasTablePermission(tableMetaData.getName(), TablePermissionSubType.INSERT);
-      editPermission = PermissionsHelper.hasTablePermission(tableMetaData.getName(), TablePermissionSubType.EDIT);
-      deletePermission = PermissionsHelper.hasTablePermission(tableMetaData.getName(), TablePermissionSubType.DELETE);
+      readPermission = PermissionsHelper.hasTablePermission(actionInput, tableMetaData.getName(), TablePermissionSubType.READ);
+      insertPermission = PermissionsHelper.hasTablePermission(actionInput, tableMetaData.getName(), TablePermissionSubType.INSERT);
+      editPermission = PermissionsHelper.hasTablePermission(actionInput, tableMetaData.getName(), TablePermissionSubType.EDIT);
+      deletePermission = PermissionsHelper.hasTablePermission(actionInput, tableMetaData.getName(), TablePermissionSubType.DELETE);
 
-      QBackendMetaData backend = QContext.getQInstance().getBackend(tableMetaData.getBackendName());
+      QBackendMetaData backend = actionInput.getInstance().getBackend(tableMetaData.getBackendName());
       if(backend != null && backend.getUsesVariants())
       {
          usesVariants = true;
-         variantTableLabel = QContext.getQInstance().getTable(backend.getVariantOptionsTableName()).getLabel();
+         variantTableLabel = actionInput.getInstance().getTable(backend.getVariantOptionsTableName()).getLabel();
       }
 
       this.helpContents = tableMetaData.getHelpContent();

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

@@ -0,0 +1,128 @@
+/*
+ * 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.queues;
+
+
+/*******************************************************************************
+ ** settings that can be applied to either an SQSQueue or an SQSQueueProvider,
+ ** to control what the SQSQueuePoller does when it receives from AWS.
+ *******************************************************************************/
+public class SQSPollerSettings
+{
+   private Integer maxNumberOfMessages;
+   private Integer waitTimeSeconds;
+   private Integer maxLoops;
+
+
+
+   /*******************************************************************************
+    ** Getter for maxNumberOfMessages
+    *******************************************************************************/
+   public Integer getMaxNumberOfMessages()
+   {
+      return (this.maxNumberOfMessages);
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for maxNumberOfMessages
+    *******************************************************************************/
+   public void setMaxNumberOfMessages(Integer maxNumberOfMessages)
+   {
+      this.maxNumberOfMessages = maxNumberOfMessages;
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for maxNumberOfMessages
+    *******************************************************************************/
+   public SQSPollerSettings withMaxNumberOfMessages(Integer maxNumberOfMessages)
+   {
+      this.maxNumberOfMessages = maxNumberOfMessages;
+      return (this);
+   }
+
+
+
+   /*******************************************************************************
+    ** Getter for waitTimeSeconds
+    *******************************************************************************/
+   public Integer getWaitTimeSeconds()
+   {
+      return (this.waitTimeSeconds);
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for waitTimeSeconds
+    *******************************************************************************/
+   public void setWaitTimeSeconds(Integer waitTimeSeconds)
+   {
+      this.waitTimeSeconds = waitTimeSeconds;
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for waitTimeSeconds
+    *******************************************************************************/
+   public SQSPollerSettings withWaitTimeSeconds(Integer waitTimeSeconds)
+   {
+      this.waitTimeSeconds = waitTimeSeconds;
+      return (this);
+   }
+
+
+
+   /*******************************************************************************
+    ** Getter for maxLoops
+    *******************************************************************************/
+   public Integer getMaxLoops()
+   {
+      return (this.maxLoops);
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for maxLoops
+    *******************************************************************************/
+   public void setMaxLoops(Integer maxLoops)
+   {
+      this.maxLoops = maxLoops;
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for maxLoops
+    *******************************************************************************/
+   public SQSPollerSettings withMaxLoops(Integer maxLoops)
+   {
+      this.maxLoops = maxLoops;
+      return (this);
+   }
+
+}

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

@@ -0,0 +1,63 @@
+/*
+ * 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.queues;
+
+
+/*******************************************************************************
+ ** SQS subclass of meta-data for a specific Queue
+ *******************************************************************************/
+public class SQSQueueMetaData extends QQueueMetaData
+{
+   private SQSPollerSettings pollerSettings;
+
+
+
+   /*******************************************************************************
+    ** Getter for pollerSettings
+    *******************************************************************************/
+   public SQSPollerSettings getPollerSettings()
+   {
+      return (this.pollerSettings);
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for pollerSettings
+    *******************************************************************************/
+   public void setPollerSettings(SQSPollerSettings pollerSettings)
+   {
+      this.pollerSettings = pollerSettings;
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for pollerSettings
+    *******************************************************************************/
+   public SQSQueueMetaData withPollerSettings(SQSPollerSettings pollerSettings)
+   {
+      this.pollerSettings = pollerSettings;
+      return (this);
+   }
+
+}

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

@@ -36,6 +36,8 @@ public class SQSQueueProviderMetaData extends QQueueProviderMetaData
    private String region;
    private String baseURL;
 
+   private SQSPollerSettings pollerSettings;
+
 
 
    /*******************************************************************************
@@ -196,4 +198,35 @@ public class SQSQueueProviderMetaData extends QQueueProviderMetaData
       return (this);
    }
 
+
+
+   /*******************************************************************************
+    ** Getter for pollerSettings
+    *******************************************************************************/
+   public SQSPollerSettings getPollerSettings()
+   {
+      return (this.pollerSettings);
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for pollerSettings
+    *******************************************************************************/
+   public void setPollerSettings(SQSPollerSettings pollerSettings)
+   {
+      this.pollerSettings = pollerSettings;
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for pollerSettings
+    *******************************************************************************/
+   public SQSQueueProviderMetaData withPollerSettings(SQSPollerSettings pollerSettings)
+   {
+      this.pollerSettings = pollerSettings;
+      return (this);
+   }
+
 }

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

@@ -23,38 +23,17 @@ package com.kingsrook.qqq.backend.core.model.metadata.security;
 
 
 import java.io.Serializable;
-import java.util.HashMap;
-import java.util.Map;
-import com.kingsrook.qqq.backend.core.context.QContext;
-import com.kingsrook.qqq.backend.core.logging.QLogger;
-import com.kingsrook.qqq.backend.core.model.session.QSession;
-import com.kingsrook.qqq.backend.core.utils.ValueUtils;
+import java.util.List;
 
 
 /*******************************************************************************
  ** Define, for a field, a lock that controls if users can or cannot see the field.
- **
- ** The lock has a defaultBehavior, which is how the field should be treated, well,
- ** by default.
- ** The lock also references a securityKeyType; whose values, when looked up in
- ** the lock's keyValueBehaviors map, change the default behavior.
- **
- ** For example, consider a lock with a keyType of 'internalOrExternalUser' (with
- ** possible values of 'internal' and 'external'), a defaultBehavior of DENY,
- ** and a keyValueBehaviors map containing internal => ALLOW.  If a session has
- ** no security key of the internalOrExternalUser type, or a key with the value of
- ** 'external', then the lock's behavior will be the default (DENY).  However,
- ** a key value of 'internal' would trigger the behavior specified for that key
- ** (ALLOW).
  *******************************************************************************/
 public class FieldSecurityLock
 {
-   private static final QLogger LOG = QLogger.getLogger(FieldSecurityLock.class);
-
-   private String   securityKeyType;
-   private Behavior defaultBehavior = Behavior.DENY;
-
-   private Map<Serializable, Behavior> keyValueBehaviors;
+   private String             securityKeyType;
+   private Behavior           defaultBehavior = Behavior.DENY;
+   private List<Serializable> overrideValues;
 
 
 
@@ -110,6 +89,7 @@ public class FieldSecurityLock
 
 
 
+
    /*******************************************************************************
     ** Getter for defaultBehavior
     *******************************************************************************/
@@ -142,82 +122,33 @@ public class FieldSecurityLock
 
 
    /*******************************************************************************
-    ** Getter for keyValueBehaviors
+    ** Getter for overrideValues
     *******************************************************************************/
-   public Map<Serializable, Behavior> getKeyValueBehaviors()
+   public List<Serializable> getOverrideValues()
    {
-      return (this.keyValueBehaviors);
+      return (this.overrideValues);
    }
 
 
 
    /*******************************************************************************
-    ** Setter for keyValueBehaviors
+    ** Setter for overrideValues
     *******************************************************************************/
-   public void setKeyValueBehaviors(Map<Serializable, Behavior> keyValueBehaviors)
+   public void setOverrideValues(List<Serializable> overrideValues)
    {
-      this.keyValueBehaviors = keyValueBehaviors;
+      this.overrideValues = overrideValues;
    }
 
 
 
    /*******************************************************************************
-    ** Fluent setter for keyValueBehaviors
+    ** Fluent setter for overrideValues
     *******************************************************************************/
-   public FieldSecurityLock withKeyValueBehaviors(Map<Serializable, Behavior> keyValueBehaviors)
+   public FieldSecurityLock withOverrideValues(List<Serializable> overrideValues)
    {
-      this.keyValueBehaviors = keyValueBehaviors;
+      this.overrideValues = overrideValues;
       return (this);
    }
 
 
-
-   /*******************************************************************************
-    ** Fluent setter for a single keyValueBehavior
-    *******************************************************************************/
-   public FieldSecurityLock withKeyValueBehavior(Serializable keyValue, Behavior behavior)
-   {
-      if(this.keyValueBehaviors == null)
-      {
-         this.keyValueBehaviors = new HashMap<>();
-      }
-      this.keyValueBehaviors.put(keyValue, behavior);
-      return (this);
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   public Behavior getBehaviorForSession(QSession session)
-   {
-      if(session != null && session.getSecurityKeyValues(this.securityKeyType) != null)
-      {
-         QSecurityKeyType securityKeyType = QContext.getQInstance().getSecurityKeyType(this.securityKeyType);
-
-         for(Serializable securityKeyValue : session.getSecurityKeyValues(this.securityKeyType))
-         {
-            try
-            {
-               if(securityKeyType.getValueType() != null)
-               {
-                  securityKeyValue = ValueUtils.getValueAsFieldType(securityKeyType.getValueType(), securityKeyValue);
-               }
-
-               if(keyValueBehaviors.containsKey(securityKeyValue))
-               {
-                  return keyValueBehaviors.get(securityKeyValue);
-               }
-            }
-            catch(Exception e)
-            {
-               LOG.warn("Error getting field behavior", e);
-            }
-         }
-      }
-
-      return getDefaultBehavior();
-   }
-
 }

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

@@ -24,7 +24,6 @@ package com.kingsrook.qqq.backend.core.model.metadata.security;
 
 import com.kingsrook.qqq.backend.core.model.metadata.QInstance;
 import com.kingsrook.qqq.backend.core.model.metadata.TopLevelMetaDataInterface;
-import com.kingsrook.qqq.backend.core.model.metadata.fields.QFieldType;
 
 
 /*******************************************************************************
@@ -38,8 +37,6 @@ public class QSecurityKeyType implements TopLevelMetaDataInterface
    private String nullValueBehaviorKeyName;
    private String possibleValueSourceName;
 
-   private QFieldType valueType;
-
 
 
    /*******************************************************************************
@@ -154,7 +151,6 @@ public class QSecurityKeyType implements TopLevelMetaDataInterface
    }
 
 
-
    /*******************************************************************************
     ** Getter for nullValueBehaviorKeyName
     *******************************************************************************/
@@ -185,34 +181,4 @@ public class QSecurityKeyType implements TopLevelMetaDataInterface
    }
 
 
-
-   /*******************************************************************************
-    ** Getter for valueType
-    *******************************************************************************/
-   public QFieldType getValueType()
-   {
-      return (this.valueType);
-   }
-
-
-
-   /*******************************************************************************
-    ** Setter for valueType
-    *******************************************************************************/
-   public void setValueType(QFieldType valueType)
-   {
-      this.valueType = valueType;
-   }
-
-
-
-   /*******************************************************************************
-    ** Fluent setter for valueType
-    *******************************************************************************/
-   public QSecurityKeyType withValueType(QFieldType valueType)
-   {
-      this.valueType = valueType;
-      return (this);
-   }
-
 }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/processes/implementations/tablesync/AbstractTableSyncTransformStep.java

@@ -245,9 +245,9 @@ public abstract class AbstractTableSyncTransformStep extends AbstractTransformSt
       // extract keys from source records //
       //////////////////////////////////////
       List<Serializable> sourceKeyList = runBackendStepInput.getRecords().stream()
-         .map(r -> r.getValueString(sourceTableKeyField))
+         .map(r -> extractSourceKeyValueFromRecord(r, sourceTableKeyField))
          .filter(Objects::nonNull)
-         .filter(v -> !"".equals(v))
+         .filter(v -> !"".equals(String.valueOf(v)))
          .collect(Collectors.toList());
 
       if(this.recordLookupHelper == null)
@@ -267,12 +267,12 @@ public abstract class AbstractTableSyncTransformStep extends AbstractTransformSt
       /////////////////////////////////////////////////////////////////
       // foreach source record, build the record we'll insert/update //
       /////////////////////////////////////////////////////////////////
-      QFieldMetaData    destinationForeignKeyField = runBackendStepInput.getInstance().getTable(destinationTableName).getField(destinationTableForeignKeyField);
+      QFieldMetaData    destinationForeignKeyField = QContext.getQInstance().getTable(destinationTableName).getField(destinationTableForeignKeyField);
       Set<Serializable> processedSourceKeys        = new HashSet<>();
       for(QRecord sourceRecord : runBackendStepInput.getRecords())
       {
          Serializable sourcePrimaryKey = sourceRecord.getValue(QContext.getQInstance().getTable(config.sourceTable).getPrimaryKeyField());
-         Serializable sourceKeyValue   = sourceRecord.getValue(sourceTableKeyField);
+         Serializable sourceKeyValue   = extractSourceKeyValueFromRecord(sourceRecord, sourceTableKeyField);
          if(processedSourceKeys.contains(sourceKeyValue))
          {
             LOG.info("Skipping duplicated source-key within page", logPair("key", sourceKeyValue));
@@ -373,6 +373,18 @@ public abstract class AbstractTableSyncTransformStep extends AbstractTransformSt
    }
 
 
+   /*******************************************************************************
+    ** Given a source record, extract what we'll use as its key from it.
+    **
+    ** Normally this is just its sourceTableKeyField value - but - a subclass may
+    ** do something more interesting, including, returning a java-record.
+    *******************************************************************************/
+   protected Serializable extractSourceKeyValueFromRecord(QRecord sourceRecord, String sourceTableKeyField)
+   {
+      return sourceRecord.getValue(sourceTableKeyField);
+   }
+
+
 
    /*******************************************************************************
     **

qqq-backend-core/src/test/java/com/kingsrook/qqq/backend/core/actions/permissions/PermissionsHelperTest.java

@@ -152,10 +152,10 @@ class PermissionsHelperTest extends BaseTest
 
          AbstractTableActionInput actionInput = new InsertInput().withTableName(TABLE_NAME);
 
-         assertTrue(PermissionsHelper.hasTablePermission(TABLE_NAME, TablePermissionSubType.READ));
-         assertFalse(PermissionsHelper.hasTablePermission(TABLE_NAME, TablePermissionSubType.INSERT));
-         assertFalse(PermissionsHelper.hasTablePermission(TABLE_NAME, TablePermissionSubType.EDIT));
-         assertFalse(PermissionsHelper.hasTablePermission(TABLE_NAME, TablePermissionSubType.DELETE));
+         assertTrue(PermissionsHelper.hasTablePermission(actionInput, TABLE_NAME, TablePermissionSubType.READ));
+         assertFalse(PermissionsHelper.hasTablePermission(actionInput, TABLE_NAME, TablePermissionSubType.INSERT));
+         assertFalse(PermissionsHelper.hasTablePermission(actionInput, TABLE_NAME, TablePermissionSubType.EDIT));
+         assertFalse(PermissionsHelper.hasTablePermission(actionInput, TABLE_NAME, TablePermissionSubType.DELETE));
          PermissionsHelper.checkTablePermissionThrowing(actionInput, TablePermissionSubType.READ);
          assertThatThrownBy(() -> PermissionsHelper.checkTablePermissionThrowing(actionInput, TablePermissionSubType.INSERT)).isInstanceOf(QPermissionDeniedException.class);
          assertThatThrownBy(() -> PermissionsHelper.checkTablePermissionThrowing(actionInput, TablePermissionSubType.EDIT)).isInstanceOf(QPermissionDeniedException.class);
@@ -169,10 +169,10 @@ class PermissionsHelperTest extends BaseTest
 
          AbstractTableActionInput actionInput = new InsertInput().withTableName(TABLE_NAME);
 
-         assertFalse(PermissionsHelper.hasTablePermission(TABLE_NAME, TablePermissionSubType.READ));
-         assertTrue(PermissionsHelper.hasTablePermission(TABLE_NAME, TablePermissionSubType.INSERT));
-         assertTrue(PermissionsHelper.hasTablePermission(TABLE_NAME, TablePermissionSubType.EDIT));
-         assertTrue(PermissionsHelper.hasTablePermission(TABLE_NAME, TablePermissionSubType.DELETE));
+         assertFalse(PermissionsHelper.hasTablePermission(actionInput, TABLE_NAME, TablePermissionSubType.READ));
+         assertTrue(PermissionsHelper.hasTablePermission(actionInput, TABLE_NAME, TablePermissionSubType.INSERT));
+         assertTrue(PermissionsHelper.hasTablePermission(actionInput, TABLE_NAME, TablePermissionSubType.EDIT));
+         assertTrue(PermissionsHelper.hasTablePermission(actionInput, TABLE_NAME, TablePermissionSubType.DELETE));
          assertThatThrownBy(() -> PermissionsHelper.checkTablePermissionThrowing(actionInput, TablePermissionSubType.READ)).isInstanceOf(QPermissionDeniedException.class);
          PermissionsHelper.checkTablePermissionThrowing(actionInput, TablePermissionSubType.INSERT);
          PermissionsHelper.checkTablePermissionThrowing(actionInput, TablePermissionSubType.EDIT);
@@ -244,10 +244,10 @@ class PermissionsHelperTest extends BaseTest
 
          AbstractTableActionInput actionInput = new InsertInput().withTableName(TABLE_NAME);
 
-         assertTrue(PermissionsHelper.hasTablePermission(TABLE_NAME, TablePermissionSubType.READ));
-         assertFalse(PermissionsHelper.hasTablePermission(TABLE_NAME, TablePermissionSubType.INSERT));
-         assertFalse(PermissionsHelper.hasTablePermission(TABLE_NAME, TablePermissionSubType.EDIT));
-         assertFalse(PermissionsHelper.hasTablePermission(TABLE_NAME, TablePermissionSubType.DELETE));
+         assertTrue(PermissionsHelper.hasTablePermission(actionInput, TABLE_NAME, TablePermissionSubType.READ));
+         assertFalse(PermissionsHelper.hasTablePermission(actionInput, TABLE_NAME, TablePermissionSubType.INSERT));
+         assertFalse(PermissionsHelper.hasTablePermission(actionInput, TABLE_NAME, TablePermissionSubType.EDIT));
+         assertFalse(PermissionsHelper.hasTablePermission(actionInput, TABLE_NAME, TablePermissionSubType.DELETE));
          PermissionsHelper.checkTablePermissionThrowing(actionInput, TablePermissionSubType.READ);
          assertThatThrownBy(() -> PermissionsHelper.checkTablePermissionThrowing(actionInput, TablePermissionSubType.INSERT)).isInstanceOf(QPermissionDeniedException.class);
          assertThatThrownBy(() -> PermissionsHelper.checkTablePermissionThrowing(actionInput, TablePermissionSubType.EDIT)).isInstanceOf(QPermissionDeniedException.class);
@@ -261,10 +261,10 @@ class PermissionsHelperTest extends BaseTest
 
          AbstractTableActionInput actionInput = new InsertInput().withTableName(TABLE_NAME);
 
-         assertFalse(PermissionsHelper.hasTablePermission(TABLE_NAME, TablePermissionSubType.READ));
-         assertTrue(PermissionsHelper.hasTablePermission(TABLE_NAME, TablePermissionSubType.INSERT));
-         assertFalse(PermissionsHelper.hasTablePermission(TABLE_NAME, TablePermissionSubType.EDIT));
-         assertFalse(PermissionsHelper.hasTablePermission(TABLE_NAME, TablePermissionSubType.DELETE));
+         assertFalse(PermissionsHelper.hasTablePermission(actionInput, TABLE_NAME, TablePermissionSubType.READ));
+         assertTrue(PermissionsHelper.hasTablePermission(actionInput, TABLE_NAME, TablePermissionSubType.INSERT));
+         assertFalse(PermissionsHelper.hasTablePermission(actionInput, TABLE_NAME, TablePermissionSubType.EDIT));
+         assertFalse(PermissionsHelper.hasTablePermission(actionInput, TABLE_NAME, TablePermissionSubType.DELETE));
          assertThatThrownBy(() -> PermissionsHelper.checkTablePermissionThrowing(actionInput, TablePermissionSubType.READ)).isInstanceOf(QPermissionDeniedException.class);
          PermissionsHelper.checkTablePermissionThrowing(actionInput, TablePermissionSubType.INSERT);
          assertThatThrownBy(() -> PermissionsHelper.checkTablePermissionThrowing(actionInput, TablePermissionSubType.EDIT)).isInstanceOf(QPermissionDeniedException.class);
@@ -581,7 +581,7 @@ class PermissionsHelperTest extends BaseTest
 
       for(TablePermissionSubType permissionSubType : TablePermissionSubType.values())
       {
-         assertTrue(PermissionsHelper.hasTablePermission(TABLE_NAME, permissionSubType), "Expected to have permission " + TABLE_NAME + ":" + permissionSubType);
+         assertTrue(PermissionsHelper.hasTablePermission(actionInput, TABLE_NAME, permissionSubType), "Expected to have permission " + TABLE_NAME + ":" + permissionSubType);
          PermissionsHelper.checkTablePermissionThrowing(actionInput, permissionSubType);
       }
 
@@ -600,7 +600,7 @@ class PermissionsHelperTest extends BaseTest
 
       for(TablePermissionSubType permissionSubType : TablePermissionSubType.values())
       {
-         assertFalse(PermissionsHelper.hasTablePermission(TABLE_NAME, permissionSubType));
+         assertFalse(PermissionsHelper.hasTablePermission(actionInput, TABLE_NAME, permissionSubType));
          assertThatThrownBy(() -> PermissionsHelper.checkTablePermissionThrowing(actionInput, permissionSubType))
             .isExactlyInstanceOf(QPermissionDeniedException.class);
       }

qqq-backend-core/src/test/java/com/kingsrook/qqq/backend/core/actions/queues/SQSQueuePollerTest.java

@@ -0,0 +1,87 @@
+/*
+ * 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.queues;
+
+
+import com.kingsrook.qqq.backend.core.BaseTest;
+import com.kingsrook.qqq.backend.core.model.metadata.queues.QQueueMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.queues.SQSPollerSettings;
+import com.kingsrook.qqq.backend.core.model.metadata.queues.SQSQueueMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.queues.SQSQueueProviderMetaData;
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+
+/*******************************************************************************
+ ** Unit test for SQSQueuePoller 
+ *******************************************************************************/
+class SQSQueuePollerTest extends BaseTest
+{
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Test
+   void testGetSqsPollerSettings()
+   {
+      ///////////////////
+      // defaults only //
+      ///////////////////
+      assertSettings(Integer.MAX_VALUE, 10, 20, SQSQueuePoller.getSqsPollerSettings(null, null));
+      assertSettings(Integer.MAX_VALUE, 10, 20, SQSQueuePoller.getSqsPollerSettings(new SQSQueueProviderMetaData(), new SQSQueueMetaData()));
+      assertSettings(Integer.MAX_VALUE, 10, 20, SQSQueuePoller.getSqsPollerSettings(new SQSQueueProviderMetaData().withPollerSettings(new SQSPollerSettings()), new SQSQueueMetaData().withPollerSettings(new SQSPollerSettings())));
+
+      ///////////////////////////////////
+      // settings only in the provider //
+      ///////////////////////////////////
+      assertSettings(100, 5, 1, SQSQueuePoller.getSqsPollerSettings(
+         new SQSQueueProviderMetaData().withPollerSettings(new SQSPollerSettings().withMaxLoops(100).withMaxNumberOfMessages(5).withWaitTimeSeconds(1)),
+         new QQueueMetaData()));
+
+      ////////////////////////////////
+      // settings only in the queue //
+      ////////////////////////////////
+      assertSettings(90, 4, 2, SQSQueuePoller.getSqsPollerSettings(
+         new SQSQueueProviderMetaData(),
+         new SQSQueueMetaData().withPollerSettings(new SQSPollerSettings().withMaxLoops(90).withMaxNumberOfMessages(4).withWaitTimeSeconds(2))));
+
+      /////////////////////////////////////////
+      // mix of default, provider, and queue //
+      /////////////////////////////////////////
+      assertSettings(Integer.MAX_VALUE, 5, 2, SQSQueuePoller.getSqsPollerSettings(
+         new SQSQueueProviderMetaData().withPollerSettings(new SQSPollerSettings().withMaxNumberOfMessages(5)),
+         new SQSQueueMetaData().withPollerSettings(new SQSPollerSettings().withWaitTimeSeconds(2))));
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private void assertSettings(Integer maxLoops, Integer maxNumberOfMessages, Integer waitTimeSeconds, SQSPollerSettings sqsPollerSettings)
+   {
+      assertEquals(maxLoops, sqsPollerSettings.getMaxLoops());
+      assertEquals(maxNumberOfMessages, sqsPollerSettings.getMaxNumberOfMessages());
+      assertEquals(waitTimeSeconds, sqsPollerSettings.getWaitTimeSeconds());
+   }
+
+}

qqq-backend-core/src/test/java/com/kingsrook/qqq/backend/core/actions/tables/GetActionTest.java

@@ -22,15 +22,28 @@
 package com.kingsrook.qqq.backend.core.actions.tables;
 
 
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
 import com.kingsrook.qqq.backend.core.BaseTest;
+import com.kingsrook.qqq.backend.core.context.QContext;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
 import com.kingsrook.qqq.backend.core.model.actions.tables.get.GetInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.get.GetOutput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.insert.InsertInput;
+import com.kingsrook.qqq.backend.core.model.data.QRecord;
+import com.kingsrook.qqq.backend.core.model.metadata.QInstance;
+import com.kingsrook.qqq.backend.core.model.metadata.fields.CaseChangeBehavior;
+import com.kingsrook.qqq.backend.core.model.metadata.fields.QFieldMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.tables.UniqueKey;
 import com.kingsrook.qqq.backend.core.modules.backend.implementations.memory.MemoryRecordStore;
+import com.kingsrook.qqq.backend.core.utils.TestUtils;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 
 /*******************************************************************************
@@ -71,4 +84,40 @@ class GetActionTest extends BaseTest
       assertNotNull(result.getRecord());
    }
 
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Test
+   void testFilterFieldBehaviors() throws QException
+   {
+      /////////////////////////////////////////////////////////////////////////
+      // insert one shape with a mixed-case name, one with an all-lower name //
+      /////////////////////////////////////////////////////////////////////////
+      new InsertAction().execute(new InsertInput(TestUtils.TABLE_NAME_SHAPE).withRecords(List.of(
+         new QRecord().withValue("name", "Triangle"),
+         new QRecord().withValue("name", "square")
+      )));
+
+      ///////////////////////////////////////////////////////////////////////////
+      // now set the shape table's name field to have a to-lower-case behavior //
+      ///////////////////////////////////////////////////////////////////////////
+      QInstance      qInstance = QContext.getQInstance();
+      QTableMetaData table     = qInstance.getTable(TestUtils.TABLE_NAME_SHAPE);
+      table.withUniqueKey(new UniqueKey("name"));
+      QFieldMetaData field = table.getField("name");
+      field.setBehaviors(Set.of(CaseChangeBehavior.TO_LOWER_CASE));
+
+      ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // confirm that if we query for "Triangle", we can't find it (because query will to-lower-case the criteria) //
+      ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      assertNull(GetAction.execute(TestUtils.TABLE_NAME_SHAPE, Map.of("name", "Triangle")));
+
+      //////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // confirm that if we query for "SQUARE", we do find it (because query will to-lower-case the criteria) //
+      //////////////////////////////////////////////////////////////////////////////////////////////////////////
+      assertNotNull(GetAction.execute(TestUtils.TABLE_NAME_SHAPE, Map.of("name", "sQuArE")));
+   }
+
 }

qqq-backend-core/src/test/java/com/kingsrook/qqq/backend/core/actions/tables/QueryActionTest.java

@@ -25,6 +25,7 @@ package com.kingsrook.qqq.backend.core.actions.tables;
 import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Set;
 import com.kingsrook.qqq.backend.core.BaseTest;
 import com.kingsrook.qqq.backend.core.actions.async.AsyncRecordPipeLoop;
 import com.kingsrook.qqq.backend.core.actions.reporting.RecordPipe;
@@ -32,13 +33,18 @@ import com.kingsrook.qqq.backend.core.actions.tables.helpers.QueryStatManager;
 import com.kingsrook.qqq.backend.core.context.QContext;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
 import com.kingsrook.qqq.backend.core.model.actions.tables.insert.InsertInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QCriteriaOperator;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QFilterCriteria;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QFilterOrderBy;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QQueryFilter;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryOutput;
 import com.kingsrook.qqq.backend.core.model.data.QRecord;
 import com.kingsrook.qqq.backend.core.model.metadata.QInstance;
+import com.kingsrook.qqq.backend.core.model.metadata.fields.CaseChangeBehavior;
+import com.kingsrook.qqq.backend.core.model.metadata.fields.QFieldMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.tables.Capability;
+import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
 import com.kingsrook.qqq.backend.core.model.querystats.QueryStat;
 import com.kingsrook.qqq.backend.core.model.querystats.QueryStatMetaDataProvider;
 import com.kingsrook.qqq.backend.core.model.session.QSession;
@@ -499,4 +505,40 @@ class QueryActionTest extends BaseTest
       insertInput.setRecords(recordList);
       new InsertAction().execute(insertInput);
    }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Test
+   void testFilterFieldBehaviors() throws QException
+   {
+      /////////////////////////////////////////////////////////////////////////
+      // insert one shape with a mixed-case name, one with an all-lower name //
+      /////////////////////////////////////////////////////////////////////////
+      new InsertAction().execute(new InsertInput(TestUtils.TABLE_NAME_SHAPE).withRecords(List.of(
+         new QRecord().withValue("name", "Triangle"),
+         new QRecord().withValue("name", "square")
+      )));
+
+      ///////////////////////////////////////////////////////////////////////////
+      // now set the shape table's name field to have a to-lower-case behavior //
+      ///////////////////////////////////////////////////////////////////////////
+      QInstance      qInstance = QContext.getQInstance();
+      QTableMetaData table     = qInstance.getTable(TestUtils.TABLE_NAME_SHAPE);
+      QFieldMetaData field     = table.getField("name");
+      field.setBehaviors(Set.of(CaseChangeBehavior.TO_LOWER_CASE));
+
+      ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // confirm that if we query for "Triangle", we can't find it (because query will to-lower-case the criteria) //
+      ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      assertEquals(0, QueryAction.execute(TestUtils.TABLE_NAME_SHAPE, new QQueryFilter(new QFilterCriteria("name", QCriteriaOperator.EQUALS, "Triangle"))).size());
+
+      //////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // confirm that if we query for "SQUARE", we do find it (because query will to-lower-case the criteria) //
+      //////////////////////////////////////////////////////////////////////////////////////////////////////////
+      assertEquals(1, QueryAction.execute(TestUtils.TABLE_NAME_SHAPE, new QQueryFilter(new QFilterCriteria("name", QCriteriaOperator.EQUALS, "SqUaRe"))).size());
+   }
+
 }

qqq-backend-core/src/test/java/com/kingsrook/qqq/backend/core/actions/values/ValueBehaviorApplierTest.java

@@ -22,16 +22,22 @@
 package com.kingsrook.qqq.backend.core.actions.values;
 
 
+import java.io.Serializable;
 import java.util.List;
 import java.util.Optional;
 import java.util.Set;
 import com.kingsrook.qqq.backend.core.BaseTest;
 import com.kingsrook.qqq.backend.core.context.QContext;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QCriteriaOperator;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QFilterCriteria;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QQueryFilter;
 import com.kingsrook.qqq.backend.core.model.data.QRecord;
 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.CaseChangeBehavior;
 import com.kingsrook.qqq.backend.core.model.metadata.fields.FieldBehavior;
 import com.kingsrook.qqq.backend.core.model.metadata.fields.FieldDisplayBehavior;
+import com.kingsrook.qqq.backend.core.model.metadata.fields.FieldFilterBehavior;
+import com.kingsrook.qqq.backend.core.model.metadata.fields.QFieldMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.fields.ValueTooLongBehavior;
 import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
 import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
@@ -39,7 +45,9 @@ import com.kingsrook.qqq.backend.core.utils.TestUtils;
 import org.junit.jupiter.api.Test;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotSame;
 import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assertions.fail;
 
@@ -158,7 +166,7 @@ class ValueBehaviorApplierTest extends BaseTest
 
       QRecord record = new QRecord().withValue("firstName", "Homer").withValue("lastName", "Simpson").withValue("ssn", "0123456789");
       ValueBehaviorApplier.applyFieldBehaviors(ValueBehaviorApplier.Action.FORMATTING, qInstance, table, List.of(record), null);
-      
+
       assertEquals("HOMER", record.getDisplayValue("firstName"));
       assertNull(record.getDisplayValue("lastName")); // noop will literally do nothing, not even pass value through.
       assertEquals("0123456789", record.getValueString("ssn")); // formatting action should not run the too-long truncate behavior
@@ -255,4 +263,140 @@ class ValueBehaviorApplierTest extends BaseTest
          }
       }
    }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Test
+   void testFilters()
+   {
+      QInstance      qInstance = QContext.getQInstance();
+      QTableMetaData table     = qInstance.getTable(TestUtils.TABLE_NAME_SHAPE);
+      QFieldMetaData field     = table.getField("name");
+      field.setBehaviors(Set.of(CaseChangeBehavior.TO_LOWER_CASE));
+
+      assertNull(ValueBehaviorApplier.applyFieldBehaviorsToFilter(qInstance, table, null, null));
+
+      QQueryFilter emptyFilter = new QQueryFilter();
+      assertSame(emptyFilter, ValueBehaviorApplier.applyFieldBehaviorsToFilter(qInstance, table, emptyFilter, null));
+
+      QQueryFilter hasCriteriaButNotUpdated = new QQueryFilter().withCriteria(new QFilterCriteria("id", QCriteriaOperator.EQUALS, 1));
+      assertSame(hasCriteriaButNotUpdated, ValueBehaviorApplier.applyFieldBehaviorsToFilter(qInstance, table, hasCriteriaButNotUpdated, null));
+
+      QQueryFilter hasSubFiltersButNotUpdated = new QQueryFilter().withSubFilters(List.of(new QQueryFilter().withCriteria(new QFilterCriteria("id", QCriteriaOperator.EQUALS, 1))));
+      assertSame(hasSubFiltersButNotUpdated, ValueBehaviorApplier.applyFieldBehaviorsToFilter(qInstance, table, hasSubFiltersButNotUpdated, null));
+
+      QQueryFilter hasCriteriaWithoutValues = new QQueryFilter().withSubFilters(List.of(new QQueryFilter().withCriteria(new QFilterCriteria("name", QCriteriaOperator.EQUALS))));
+      assertSame(hasCriteriaWithoutValues, ValueBehaviorApplier.applyFieldBehaviorsToFilter(qInstance, table, hasCriteriaWithoutValues, null));
+
+      QQueryFilter hasCriteriaAndSubFiltersButNotUpdated = new QQueryFilter()
+         .withCriteria(new QFilterCriteria("id", QCriteriaOperator.EQUALS, 1))
+         .withSubFilters(List.of(new QQueryFilter().withCriteria(new QFilterCriteria("id", QCriteriaOperator.EQUALS, 1))));
+      assertSame(hasCriteriaAndSubFiltersButNotUpdated, ValueBehaviorApplier.applyFieldBehaviorsToFilter(qInstance, table, hasCriteriaAndSubFiltersButNotUpdated, null));
+
+      QQueryFilter hasCriteriaToUpdate = new QQueryFilter().withCriteria(new QFilterCriteria("name", QCriteriaOperator.EQUALS, "Triangle"));
+      QQueryFilter hasCriteriaUpdated  = ValueBehaviorApplier.applyFieldBehaviorsToFilter(qInstance, table, hasCriteriaToUpdate, null);
+      assertNotSame(hasCriteriaToUpdate, hasCriteriaUpdated);
+      assertEquals("triangle", hasCriteriaUpdated.getCriteria().get(0).getValues().get(0));
+      assertEquals(hasCriteriaToUpdate.getSubFilters(), hasCriteriaUpdated.getSubFilters());
+
+      QQueryFilter hasSubFilterToUpdate = new QQueryFilter().withSubFilter(new QQueryFilter().withCriteria(new QFilterCriteria("name", QCriteriaOperator.EQUALS, "Oval")));
+      QQueryFilter hasSubFilterUpdated  = ValueBehaviorApplier.applyFieldBehaviorsToFilter(qInstance, table, hasSubFilterToUpdate, null);
+      assertNotSame(hasSubFilterToUpdate, hasSubFilterUpdated);
+      assertEquals("oval", hasSubFilterUpdated.getSubFilters().get(0).getCriteria().get(0).getValues().get(0));
+      assertEquals(hasSubFilterToUpdate.getCriteria(), hasSubFilterUpdated.getCriteria());
+
+      QQueryFilter hasCriteriaAndSubFilterToUpdate = new QQueryFilter()
+         .withCriteria(new QFilterCriteria("name", QCriteriaOperator.EQUALS, "Square"))
+         .withSubFilter(new QQueryFilter().withCriteria(new QFilterCriteria("name", QCriteriaOperator.EQUALS, "Circle")));
+      QQueryFilter hasCriteriaAndSubFilterUpdated = ValueBehaviorApplier.applyFieldBehaviorsToFilter(qInstance, table, hasCriteriaAndSubFilterToUpdate, null);
+      assertNotSame(hasCriteriaAndSubFilterToUpdate, hasCriteriaAndSubFilterUpdated);
+      assertEquals("square", hasCriteriaAndSubFilterUpdated.getCriteria().get(0).getValues().get(0));
+      assertEquals("circle", hasCriteriaAndSubFilterUpdated.getSubFilters().get(0).getCriteria().get(0).getValues().get(0));
+
+      QQueryFilter hasMultiValueCriteriaToUpdate = new QQueryFilter().withCriteria(new QFilterCriteria("name", QCriteriaOperator.IN, "Triangle", "Square"));
+      QQueryFilter hasMultiValueCriteriaUpdated  = ValueBehaviorApplier.applyFieldBehaviorsToFilter(qInstance, table, hasMultiValueCriteriaToUpdate, null);
+      assertNotSame(hasMultiValueCriteriaToUpdate, hasMultiValueCriteriaUpdated);
+      assertEquals(List.of("triangle", "square"), hasMultiValueCriteriaUpdated.getCriteria().get(0).getValues());
+      assertEquals(hasMultiValueCriteriaToUpdate.getSubFilters(), hasMultiValueCriteriaUpdated.getSubFilters());
+
+      QQueryFilter hasMultipleCriteriaOnlyToUpdate = new QQueryFilter()
+         .withCriteria(new QFilterCriteria("name", QCriteriaOperator.EQUALS, "Square"))
+         .withCriteria(new QFilterCriteria("id", QCriteriaOperator.IS_NOT_BLANK));
+
+      QQueryFilter hasMultipleCriteriaOnlyOneUpdated = ValueBehaviorApplier.applyFieldBehaviorsToFilter(qInstance, table, hasMultipleCriteriaOnlyToUpdate, null);
+      assertNotSame(hasMultipleCriteriaOnlyToUpdate, hasMultipleCriteriaOnlyOneUpdated);
+      assertEquals(2, hasMultipleCriteriaOnlyOneUpdated.getCriteria().size());
+      assertEquals(List.of("square"), hasMultipleCriteriaOnlyOneUpdated.getCriteria().get(0).getValues());
+      assertEquals(hasMultipleCriteriaOnlyToUpdate.getSubFilters(), hasMultipleCriteriaOnlyOneUpdated.getSubFilters());
+
+      //////////////////////////////////////////////////////////
+      // set 2 behaviors on the field - make sure both happen //
+      //////////////////////////////////////////////////////////
+      field.setBehaviors(Set.of(CaseChangeBehavior.TO_LOWER_CASE, new AppendSomethingBehavior("-x")));
+      QQueryFilter criteriaValueToUpdateTwice = new QQueryFilter().withCriteria(new QFilterCriteria("name", QCriteriaOperator.EQUALS, "Triangle"));
+      QQueryFilter criteriaValueUpdatedTwice  = ValueBehaviorApplier.applyFieldBehaviorsToFilter(qInstance, table, criteriaValueToUpdateTwice, null);
+      assertNotSame(criteriaValueToUpdateTwice, criteriaValueUpdatedTwice);
+      assertEquals("triangle-x", criteriaValueUpdatedTwice.getCriteria().get(0).getValues().get(0));
+      assertEquals(criteriaValueToUpdateTwice.getSubFilters(), criteriaValueUpdatedTwice.getSubFilters());
+   }
+
+
+
+   /***************************************************************************
+    *
+    ***************************************************************************/
+   public static class AppendSomethingBehavior implements FieldBehavior<AppendSomethingBehavior>, FieldFilterBehavior<AppendSomethingBehavior>
+   {
+      private String something;
+
+
+
+      /*******************************************************************************
+       ** Constructor
+       **
+       *******************************************************************************/
+      public AppendSomethingBehavior(String something)
+      {
+         this.something = something;
+      }
+
+
+
+      /***************************************************************************
+       *
+       ***************************************************************************/
+      @Override
+      public Serializable applyToFilterCriteriaValue(Serializable value, QInstance instance, QTableMetaData table, QFieldMetaData field)
+      {
+         return value + something;
+      }
+
+
+
+      /***************************************************************************
+       *
+       ***************************************************************************/
+      @Override
+      public AppendSomethingBehavior getDefault()
+      {
+         return null;
+      }
+
+
+
+      /***************************************************************************
+       *
+       ***************************************************************************/
+      @Override
+      public void apply(ValueBehaviorApplier.Action action, List<QRecord> recordList, QInstance instance, QTableMetaData table, QFieldMetaData field)
+      {
+         //////////
+         // noop //
+         //////////
+      }
+   }
+
 }

qqq-backend-core/src/test/java/com/kingsrook/qqq/backend/core/instances/QInstanceValidatorTest.java

@@ -1945,8 +1945,8 @@ public class QInstanceValidatorTest extends BaseTest
       assertValidationFailureReasons((qInstance -> lockExtractor.apply(qInstance).setSecurityKeyType(" ")), "missing a securityKeyType");
       assertValidationFailureReasons((qInstance -> lockExtractor.apply(qInstance).setSecurityKeyType("notAKeyType")), "unrecognized securityKeyType");
       assertValidationFailureReasons((qInstance -> lockExtractor.apply(qInstance).setDefaultBehavior(null)), "missing a defaultBehavior");
-      assertValidationFailureReasons((qInstance -> lockExtractor.apply(qInstance).setKeyValueBehaviors(null)), "missing keyValueBehaviors");
-      assertValidationFailureReasons((qInstance -> lockExtractor.apply(qInstance).setKeyValueBehaviors(Collections.emptyMap())), "missing keyValueBehaviors");
+      assertValidationFailureReasons((qInstance -> lockExtractor.apply(qInstance).setOverrideValues(null)), "missing overrideValues");
+      assertValidationFailureReasons((qInstance -> lockExtractor.apply(qInstance).setOverrideValues(Collections.emptyList())), "missing overrideValues");
    }
 
 

qqq-backend-core/src/test/java/com/kingsrook/qqq/backend/core/model/actions/tables/query/QueryOutputListTest.java

@@ -0,0 +1,110 @@
+/*
+ * 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.tables.query;
+
+
+import java.util.Collections;
+import com.kingsrook.qqq.backend.core.BaseTest;
+import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.logging.QCollectingLogger;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
+import com.kingsrook.qqq.backend.core.model.data.QRecord;
+import com.kingsrook.qqq.backend.core.utils.TestUtils;
+import org.apache.logging.log4j.Level;
+import org.junit.jupiter.api.Test;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+
+/*******************************************************************************
+ ** Unit test for QueryOutputList 
+ *******************************************************************************/
+class QueryOutputListTest extends BaseTest
+{
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Test
+   void testLogSize() throws QException
+   {
+      QueryInput  queryInput  = new QueryInput(TestUtils.TABLE_NAME_PERSON);
+      QueryOutput queryOutput = new QueryOutput(queryInput);
+
+      QCollectingLogger collectingLogger = QLogger.activateCollectingLoggerForClass(QueryOutputList.class);
+
+      ///////////////////////
+      // set up our limits //
+      ///////////////////////
+      int infoLimit  = 10;
+      int warnLimit  = 20;
+      int errorLimit = 30;
+
+      QueryOutputList.setLogSizeInfoOver(infoLimit);
+      QueryOutputList.setLogSizeWarnOver(warnLimit);
+      QueryOutputList.setLogSizeErrorOver(errorLimit);
+
+      ////////////////////////////
+      // add records one-by-one //
+      ////////////////////////////
+      for(int i = 0; i < errorLimit; i++)
+      {
+         queryOutput.addRecord(new QRecord());
+      }
+
+      ///////////////////////////////////////////////////////////////
+      // assert we got the expected logs as each level was crossed //
+      ///////////////////////////////////////////////////////////////
+      assertEquals(3, collectingLogger.getCollectedMessages().size());
+
+      assertEquals(Level.INFO, collectingLogger.getCollectedMessages().get(0).getLevel());
+      assertThat(collectingLogger.getCollectedMessages().get(0).getMessage())
+         .contains("\"noRecords\":" + infoLimit)
+         .contains("\"tableName\":\"" + TestUtils.TABLE_NAME_PERSON + "\"");
+
+      assertEquals(Level.WARN, collectingLogger.getCollectedMessages().get(1).getLevel());
+      assertThat(collectingLogger.getCollectedMessages().get(1).getMessage())
+         .contains("\"noRecords\":" + warnLimit)
+         .contains("\"tableName\":\"" + TestUtils.TABLE_NAME_PERSON + "\"");
+
+      assertEquals(Level.ERROR, collectingLogger.getCollectedMessages().get(2).getLevel());
+      assertThat(collectingLogger.getCollectedMessages().get(2).getMessage())
+         .contains("\"noRecords\":" + errorLimit)
+         .contains("\"tableName\":\"" + TestUtils.TABLE_NAME_PERSON + "\"");
+
+      //////////////////////////////////////////////////////////////////////////////////////////
+      // reset the logger - then run again, doing a bulk add that goes straight to error size //
+      //////////////////////////////////////////////////////////////////////////////////////////
+      collectingLogger.clear();
+      queryOutput = new QueryOutput(queryInput);
+      int bulkSize = errorLimit + 1;
+      queryOutput.addRecords(Collections.nCopies(bulkSize, new QRecord()));
+
+      assertEquals(1, collectingLogger.getCollectedMessages().size());
+      assertEquals(Level.ERROR, collectingLogger.getCollectedMessages().get(0).getLevel());
+      assertThat(collectingLogger.getCollectedMessages().get(0).getMessage())
+         .contains("\"noRecords\":" + bulkSize)
+         .contains("\"tableName\":\"" + TestUtils.TABLE_NAME_PERSON + "\"");
+
+   }
+
+}

qqq-backend-core/src/test/java/com/kingsrook/qqq/backend/core/model/metadata/fields/CaseChangeBehaviorTest.java

@@ -0,0 +1,242 @@
+/*
+ * 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.fields;
+
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+import com.kingsrook.qqq.backend.core.BaseTest;
+import com.kingsrook.qqq.backend.core.actions.tables.GetAction;
+import com.kingsrook.qqq.backend.core.actions.tables.InsertAction;
+import com.kingsrook.qqq.backend.core.actions.tables.QueryAction;
+import com.kingsrook.qqq.backend.core.actions.tables.UpdateAction;
+import com.kingsrook.qqq.backend.core.actions.values.ValueBehaviorApplier;
+import com.kingsrook.qqq.backend.core.context.QContext;
+import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.model.actions.tables.insert.InsertInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.update.UpdateInput;
+import com.kingsrook.qqq.backend.core.model.data.QRecord;
+import com.kingsrook.qqq.backend.core.model.metadata.QInstance;
+import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
+import com.kingsrook.qqq.backend.core.utils.TestUtils;
+import com.kingsrook.qqq.backend.core.utils.collections.ListBuilder;
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+
+/*******************************************************************************
+ ** Unit test for CaseChangeBehavior 
+ *******************************************************************************/
+class CaseChangeBehaviorTest extends BaseTest
+{
+   public static final String FIELD = "firstName" ;
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Test
+   void testNone()
+   {
+      assertNull(applyToRecord(CaseChangeBehavior.NONE, new QRecord(), ValueBehaviorApplier.Action.INSERT).getValue(FIELD));
+      assertNull(applyToRecord(CaseChangeBehavior.NONE, new QRecord().withValue(FIELD, null), ValueBehaviorApplier.Action.INSERT).getValue(FIELD));
+      assertEquals("John", applyToRecord(CaseChangeBehavior.NONE, new QRecord().withValue(FIELD, "John"), ValueBehaviorApplier.Action.INSERT).getValue(FIELD));
+
+      assertEquals(ListBuilder.of("John", null, "Jane"), applyToRecords(CaseChangeBehavior.NONE, List.of(
+            new QRecord().withValue(FIELD, "John"),
+            new QRecord(),
+            new QRecord().withValue(FIELD, "Jane")),
+         ValueBehaviorApplier.Action.INSERT).stream().map(r -> r.getValueString(FIELD)).toList());
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Test
+   void testToUpperCase()
+   {
+      assertNull(applyToRecord(CaseChangeBehavior.TO_UPPER_CASE, new QRecord(), ValueBehaviorApplier.Action.INSERT).getValue(FIELD));
+      assertNull(applyToRecord(CaseChangeBehavior.TO_UPPER_CASE, new QRecord().withValue(FIELD, null), ValueBehaviorApplier.Action.INSERT).getValue(FIELD));
+      assertEquals("JOHN", applyToRecord(CaseChangeBehavior.TO_UPPER_CASE, new QRecord().withValue(FIELD, "John"), ValueBehaviorApplier.Action.INSERT).getValue(FIELD));
+
+      assertEquals(ListBuilder.of("JOHN", null, "JANE"), applyToRecords(CaseChangeBehavior.TO_UPPER_CASE, List.of(
+            new QRecord().withValue(FIELD, "John"),
+            new QRecord(),
+            new QRecord().withValue(FIELD, "Jane")),
+         ValueBehaviorApplier.Action.INSERT).stream().map(r -> r.getValueString(FIELD)).toList());
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Test
+   void testToLowerCase()
+   {
+      assertNull(applyToRecord(CaseChangeBehavior.TO_LOWER_CASE, new QRecord(), ValueBehaviorApplier.Action.INSERT).getValue(FIELD));
+      assertNull(applyToRecord(CaseChangeBehavior.TO_LOWER_CASE, new QRecord().withValue(FIELD, null), ValueBehaviorApplier.Action.INSERT).getValue(FIELD));
+      assertEquals("john", applyToRecord(CaseChangeBehavior.TO_LOWER_CASE, new QRecord().withValue(FIELD, "John"), ValueBehaviorApplier.Action.INSERT).getValue(FIELD));
+
+      assertEquals(ListBuilder.of("john", null, "jane"), applyToRecords(CaseChangeBehavior.TO_LOWER_CASE, List.of(
+            new QRecord().withValue(FIELD, "John"),
+            new QRecord(),
+            new QRecord().withValue(FIELD, "Jane")),
+         ValueBehaviorApplier.Action.INSERT).stream().map(r -> r.getValueString(FIELD)).toList());
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private QRecord applyToRecord(CaseChangeBehavior behavior, QRecord record, ValueBehaviorApplier.Action action)
+   {
+      return (applyToRecords(behavior, List.of(record), action).get(0));
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private List<QRecord> applyToRecords(CaseChangeBehavior behavior, List<QRecord> records, ValueBehaviorApplier.Action action)
+   {
+      QTableMetaData table = QContext.getQInstance().getTable(TestUtils.TABLE_NAME_PERSON_MEMORY);
+      behavior.apply(action, records, QContext.getQInstance(), table, table.getField(FIELD));
+      return (records);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Test
+   void testReads() throws QException
+   {
+      TestUtils.insertDefaultShapes(QContext.getQInstance());
+
+      List<QRecord> records = QueryAction.execute(TestUtils.TABLE_NAME_SHAPE, null);
+      assertEquals(Set.of("Triangle", "Square", "Circle"), records.stream().map(r -> r.getValueString("name")).collect(Collectors.toSet()));
+
+      QFieldMetaData field = QContext.getQInstance().getTable(TestUtils.TABLE_NAME_SHAPE).getField("name");
+      field.setBehaviors(Set.of(CaseChangeBehavior.TO_UPPER_CASE));
+
+      records = QueryAction.execute(TestUtils.TABLE_NAME_SHAPE, null);
+      assertEquals(Set.of("TRIANGLE", "SQUARE", "CIRCLE"), records.stream().map(r -> r.getValueString("name")).collect(Collectors.toSet()));
+
+      field.setBehaviors(Set.of(CaseChangeBehavior.TO_LOWER_CASE));
+      assertEquals("triangle", GetAction.execute(TestUtils.TABLE_NAME_SHAPE, 1).getValueString("name"));
+
+      field.setBehaviors(Set.of(CaseChangeBehavior.NONE));
+      assertEquals("Triangle", GetAction.execute(TestUtils.TABLE_NAME_SHAPE, 1).getValueString("name"));
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Test
+   void testWrites() throws QException
+   {
+      Integer id = 100;
+
+      QFieldMetaData field = QContext.getQInstance().getTable(TestUtils.TABLE_NAME_SHAPE).getField("name");
+      field.setBehaviors(Set.of(CaseChangeBehavior.TO_UPPER_CASE));
+      new InsertAction().execute(new InsertInput(TestUtils.TABLE_NAME_SHAPE).withRecord(new QRecord().withValue("id", id).withValue("name", "Octagon")));
+
+      //////////////////////////////////////////////////////////////////////////////////
+      // turn off the to-upper-case behavior, so we'll see what was actually inserted //
+      //////////////////////////////////////////////////////////////////////////////////
+      field.setBehaviors(Collections.emptySet());
+      assertEquals("OCTAGON", GetAction.execute(TestUtils.TABLE_NAME_SHAPE, id).getValueString("name"));
+
+      ////////////////////////////////////////////
+      // change to toLowerCase and do an update //
+      ////////////////////////////////////////////
+      field.setBehaviors(Set.of(CaseChangeBehavior.TO_LOWER_CASE));
+      new UpdateAction().execute(new UpdateInput(TestUtils.TABLE_NAME_SHAPE).withRecord(new QRecord().withValue("id", id).withValue("name", "Octagon")));
+
+      ////////////////////////////////////////////////////////////////////////////////////
+      // turn off the to-lower-case behavior, so we'll see what was actually udpated to //
+      ////////////////////////////////////////////////////////////////////////////////////
+      field.setBehaviors(Collections.emptySet());
+      assertEquals("octagon", GetAction.execute(TestUtils.TABLE_NAME_SHAPE, id).getValueString("name"));
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Test
+   void testFilter()
+   {
+      QInstance      qInstance = QContext.getQInstance();
+      QTableMetaData table     = qInstance.getTable(TestUtils.TABLE_NAME_SHAPE);
+      QFieldMetaData field     = table.getField("name");
+      field.setBehaviors(Set.of(CaseChangeBehavior.TO_UPPER_CASE));
+      assertEquals("SQUARE", CaseChangeBehavior.TO_UPPER_CASE.applyToFilterCriteriaValue("square", qInstance, table, field));
+
+      field.setBehaviors(Set.of(CaseChangeBehavior.TO_LOWER_CASE));
+      assertEquals("triangle", CaseChangeBehavior.TO_LOWER_CASE.applyToFilterCriteriaValue("Triangle", qInstance, table, field));
+
+      field.setBehaviors(Set.of(CaseChangeBehavior.NONE));
+      assertEquals("Circle", CaseChangeBehavior.NONE.applyToFilterCriteriaValue("Circle", qInstance, table, field));
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Test
+   void testValidation()
+   {
+      QTableMetaData table = QContext.getQInstance().getTable(TestUtils.TABLE_NAME_SHAPE);
+
+      ///////////////////////////////////////////
+      // should be no errors on a string field //
+      ///////////////////////////////////////////
+      assertTrue(CaseChangeBehavior.TO_UPPER_CASE.validateBehaviorConfiguration(table, table.getField("name")).isEmpty());
+
+      //////////////////////////////////////////
+      // should be an error on a number field //
+      //////////////////////////////////////////
+      assertEquals(1, CaseChangeBehavior.TO_LOWER_CASE.validateBehaviorConfiguration(table, table.getField("id")).size());
+
+      /////////////////////////////////////////
+      // NONE should be allowed on any field //
+      /////////////////////////////////////////
+      assertTrue(CaseChangeBehavior.NONE.validateBehaviorConfiguration(table, table.getField("id")).isEmpty());
+   }
+
+}

qqq-backend-core/src/test/java/com/kingsrook/qqq/backend/core/model/metadata/frontend/QFrontendTableMetaDataTest.java

@@ -1,89 +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.frontend;
-
-
-import java.util.function.Supplier;
-import com.kingsrook.qqq.backend.core.BaseTest;
-import com.kingsrook.qqq.backend.core.context.QContext;
-import com.kingsrook.qqq.backend.core.model.metadata.fields.QFieldType;
-import com.kingsrook.qqq.backend.core.model.metadata.security.FieldSecurityLock;
-import com.kingsrook.qqq.backend.core.model.metadata.security.QSecurityKeyType;
-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.TestUtils;
-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-
-/*******************************************************************************
- ** Unit test for QFrontendTableMetaData 
- *******************************************************************************/
-class QFrontendTableMetaDataTest extends BaseTest
-{
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   @Test
-   void testFieldLocks()
-   {
-      QContext.getQInstance().addSecurityKeyType(new QSecurityKeyType()
-         .withName("allowedToSeeFirstName")
-         .withValueType(QFieldType.BOOLEAN));
-
-      FieldSecurityLock fieldSecurityLock = new FieldSecurityLock()
-         .withSecurityKeyType("allowedToSeeFirstName")
-         .withDefaultBehavior(FieldSecurityLock.Behavior.DENY)
-         .withKeyValueBehavior(true, FieldSecurityLock.Behavior.ALLOW);
-
-      QTableMetaData table = QContext.getQInstance().getTable(TestUtils.TABLE_NAME_PERSON_MEMORY);
-      table.getField("firstName").withFieldSecurityLock(fieldSecurityLock);
-
-      Supplier<QFrontendTableMetaData> run = () -> new QFrontendTableMetaData(QContext.getQInstance().getBackendForTable(TestUtils.TABLE_NAME_PERSON_MEMORY), table, true, false);
-
-      //////////////////////////////////////////////////////////////
-      // default session (no key) should NOT get to see firstName //
-      //////////////////////////////////////////////////////////////
-      assertFalse(run.get().getFields().containsKey("firstName"));
-
-      /////////////////////////////////////
-      // with the key=true, then allowed //
-      /////////////////////////////////////
-      QContext.setQSession(new QSession().withSecurityKeyValue("allowedToSeeFirstName", true));
-      assertTrue(run.get().getFields().containsKey("firstName"));
-
-      ////////////////////////////////////////
-      // try a string version of the key... //
-      ////////////////////////////////////////
-      QContext.setQSession(new QSession().withSecurityKeyValue("allowedToSeeFirstName", "true"));
-      assertTrue(run.get().getFields().containsKey("firstName"));
-
-      ////////////////////////////
-      // try unrecognized value //
-      ////////////////////////////
-      QContext.setQSession(new QSession().withSecurityKeyValue("allowedToSeeFirstName", "nope"));
-      assertFalse(run.get().getFields().containsKey("firstName"));
-   }
-
-}

qqq-backend-core/src/test/java/com/kingsrook/qqq/backend/core/model/metadata/security/FieldSecurityLockTest.java

@@ -1,85 +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.security;
-
-
-import com.kingsrook.qqq.backend.core.BaseTest;
-import com.kingsrook.qqq.backend.core.context.QContext;
-import com.kingsrook.qqq.backend.core.model.metadata.fields.QFieldType;
-import com.kingsrook.qqq.backend.core.model.session.QSession;
-import com.kingsrook.qqq.backend.core.utils.TestUtils;
-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-
-
-/*******************************************************************************
- ** Unit test for FieldSecurityLock 
- *******************************************************************************/
-class FieldSecurityLockTest extends BaseTest
-{
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   @Test
-   void testGetBehaviorForSession()
-   {
-      QContext.getQInstance().addSecurityKeyType(new QSecurityKeyType()
-         .withName("foo")
-         .withValueType(QFieldType.STRING));
-
-      FieldSecurityLock fieldSecurityLock = new FieldSecurityLock()
-         .withSecurityKeyType("foo")
-         .withDefaultBehavior(FieldSecurityLock.Behavior.DENY)
-         .withKeyValueBehavior("bar", FieldSecurityLock.Behavior.ALLOW)
-         .withKeyValueBehavior("baz", FieldSecurityLock.Behavior.ALLOW)
-         .withKeyValueBehavior("boo", FieldSecurityLock.Behavior.DENY);
-
-      QContext.getQInstance().getTable(TestUtils.TABLE_NAME_PERSON_MEMORY)
-         .getField("firstName").withFieldSecurityLock(fieldSecurityLock);
-
-      ////////////////////////////
-      // no key value = default //
-      ////////////////////////////
-      assertEquals(FieldSecurityLock.Behavior.DENY, fieldSecurityLock.getBehaviorForSession(new QSession()));
-
-      /////////////////////////////////////////////////
-      // values specified get the behavior specified //
-      /////////////////////////////////////////////////
-      assertEquals(FieldSecurityLock.Behavior.ALLOW, fieldSecurityLock.getBehaviorForSession(new QSession().withSecurityKeyValue("foo", "bar")));
-      assertEquals(FieldSecurityLock.Behavior.ALLOW, fieldSecurityLock.getBehaviorForSession(new QSession().withSecurityKeyValue("foo", "baz")));
-      assertEquals(FieldSecurityLock.Behavior.DENY, fieldSecurityLock.getBehaviorForSession(new QSession().withSecurityKeyValue("foo", "boo")));
-
-      //////////////////////////////////////////////
-      // unrecognized values get default behavior //
-      //////////////////////////////////////////////
-      assertEquals(FieldSecurityLock.Behavior.DENY, fieldSecurityLock.getBehaviorForSession(new QSession().withSecurityKeyValue("foo", "huh")));
-
-      /////////////////////////////////////////////////
-      // if multiple key values, the first one wins. //
-      /////////////////////////////////////////////////
-      assertEquals(FieldSecurityLock.Behavior.ALLOW, fieldSecurityLock.getBehaviorForSession(new QSession().withSecurityKeyValue("foo", "bar").withSecurityKeyValue("foo", "boo")));
-      assertEquals(FieldSecurityLock.Behavior.DENY, fieldSecurityLock.getBehaviorForSession(new QSession().withSecurityKeyValue("foo", "boo").withSecurityKeyValue("foo", "foo")));
-
-   }
-
-}

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

@@ -660,7 +660,7 @@ public class TestUtils
          .withField(new QFieldMetaData("total", QFieldType.DECIMAL).withDisplayFormat(DisplayFormat.CURRENCY).withFieldSecurityLock(new FieldSecurityLock()
             .withSecurityKeyType(SECURITY_KEY_TYPE_INTERNAL_OR_EXTERNAL)
             .withDefaultBehavior(FieldSecurityLock.Behavior.DENY)
-            .withKeyValueBehavior("internal", FieldSecurityLock.Behavior.ALLOW)
+            .withOverrideValues(List.of("internal"))
          ));
    }
 

qqq-backend-module-rdbms/src/main/java/com/kingsrook/qqq/backend/module/rdbms/actions/RDBMSQueryAction.java

@@ -55,6 +55,7 @@ import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
 import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
 import com.kingsrook.qqq.backend.core.utils.Pair;
 import com.kingsrook.qqq.backend.module.rdbms.jdbc.QueryManager;
+import com.kingsrook.qqq.backend.module.rdbms.model.metadata.RDBMSBackendMetaData;
 import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
 
 
@@ -356,18 +357,29 @@ public class RDBMSQueryAction extends AbstractRDBMSAction implements QueryInterf
     *******************************************************************************/
    private PreparedStatement createStatement(Connection connection, String sql, QueryInput queryInput) throws SQLException
    {
-      if(connection.getClass().getName().startsWith("com.mysql"))
+      /////////////////////////////////////////////////////////////////////////
+      // if we're allowed to use the mysqlResultSetOptimization, and we have //
+      // the query hint of "potentially large no of results", then check if  //
+      // our backend is indeed mysql, and if so, then apply those settings.  //
+      /////////////////////////////////////////////////////////////////////////
+      if(mysqlResultSetOptimizationEnabled && queryInput.hasQueryHint(QueryHint.POTENTIALLY_LARGE_NUMBER_OF_RESULTS))
       {
-         ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-         // if we're allowed to use the mysqlResultSetOptimization, and we have the query hint of "expected large result set", then do it. //
-         ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-         if(mysqlResultSetOptimizationEnabled && queryInput.getQueryHints() != null && queryInput.getQueryHints().contains(QueryHint.POTENTIALLY_LARGE_NUMBER_OF_RESULTS))
+         RDBMSBackendMetaData rdbmsBackendMetaData = (RDBMSBackendMetaData) queryInput.getBackend();
+
+         ////////////////////////////////////////////////////////////////////////////
+         // todo - remove "aurora" - it's a legacy value here for a staged rollout //
+         ////////////////////////////////////////////////////////////////////////////
+         if(RDBMSBackendMetaData.VENDOR_MYSQL.equals(rdbmsBackendMetaData.getVendor()) || RDBMSBackendMetaData.VENDOR_AURORA_MYSQL.equals(rdbmsBackendMetaData.getVendor()) || "aurora".equals(rdbmsBackendMetaData.getVendor()))
          {
-            /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            // mysql "optimization", presumably here - from Result Set section of https://dev.mysql.com/doc/connector-j/en/connector-j-reference-implementation-notes.html //
-            // without this change, we saw ~10 seconds of "wait" time, before results would start to stream out of a large query (e.g., > 1,000,000 rows).                 //
-            // with this change, we start to get results immediately, and the total runtime also seems lower...                                                            //
-            /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+            //////////////////////////////////////////////////////////////////////////////////////////////////////
+            // mysql "optimization", presumably here - from Result Set section of                               //
+            // https://dev.mysql.com/doc/connector-j/en/connector-j-reference-implementation-notes.html without //
+            // this change, we saw ~10 seconds of "wait" time, before results would start to stream out of a    //
+            // large query (e.g., > 1,000,000 rows).                                                            //
+            // with this change, we start to get results immediately, and the total runtime also seems lower... //
+            // perhaps more importantly, without this change, the whole result set goes into memory - but with  //
+            // this change, it is streamed.                                                                     //
+            //////////////////////////////////////////////////////////////////////////////////////////////////////
             PreparedStatement statement = connection.prepareStatement(sql, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
             statement.setFetchSize(Integer.MIN_VALUE);
             return (statement);

qqq-backend-module-rdbms/src/main/java/com/kingsrook/qqq/backend/module/rdbms/jdbc/ConnectionManager.java

@@ -150,8 +150,11 @@ public class ConnectionManager
 
       return switch(backend.getVendor())
       {
-         case "mysql", "aurora" -> "com.mysql.cj.jdbc.Driver";
-         case "h2" -> "org.h2.Driver";
+         ////////////////////////////////////////////////////////////////////////////
+         // todo - remove "aurora" - it's a legacy value here for a staged rollout //
+         ////////////////////////////////////////////////////////////////////////////
+         case RDBMSBackendMetaData.VENDOR_MYSQL, RDBMSBackendMetaData.VENDOR_AURORA_MYSQL, "aurora" -> "com.mysql.cj.jdbc.Driver";
+         case RDBMSBackendMetaData.VENDOR_H2 -> "org.h2.Driver";
          default -> throw (new IllegalStateException("We do not know what jdbc driver to use for vendor name [" + backend.getVendor() + "].  Try setting jdbcDriverClassName in your backend meta data."));
       };
    }
@@ -170,11 +173,17 @@ public class ConnectionManager
 
       return switch(backend.getVendor())
       {
-         // TODO aws-mysql-jdbc driver not working when running on AWS
+         ////////////////////////////////////////////////////////////////
+         // TODO aws-mysql-jdbc driver not working when running on AWS //
+         ////////////////////////////////////////////////////////////////
          // jdbcURL = "jdbc:mysql:aws://" + backend.getHostName() + ":" + backend.getPort() + "/" + backend.getDatabaseName() + "?rewriteBatchedStatements=true&zeroDateTimeBehavior=CONVERT_TO_NULL";
-         case "aurora" -> "jdbc:mysql://" + backend.getHostName() + ":" + backend.getPort() + "/" + backend.getDatabaseName() + "?rewriteBatchedStatements=true&zeroDateTimeBehavior=convertToNull&useSSL=false";
-         case "mysql" -> "jdbc:mysql://" + backend.getHostName() + ":" + backend.getPort() + "/" + backend.getDatabaseName() + "?rewriteBatchedStatements=true&zeroDateTimeBehavior=convertToNull";
-         case "h2" -> "jdbc:h2:" + backend.getHostName() + ":" + backend.getDatabaseName() + ";MODE=MySQL;DB_CLOSE_DELAY=-1";
+
+         ////////////////////////////////////////////////////////////////////////////
+         // todo - remove "aurora" - it's a legacy value here for a staged rollout //
+         ////////////////////////////////////////////////////////////////////////////
+         case RDBMSBackendMetaData.VENDOR_AURORA_MYSQL, "aurora" -> "jdbc:mysql://" + backend.getHostName() + ":" + backend.getPort() + "/" + backend.getDatabaseName() + "?rewriteBatchedStatements=true&zeroDateTimeBehavior=convertToNull&useSSL=false";
+         case RDBMSBackendMetaData.VENDOR_MYSQL -> "jdbc:mysql://" + backend.getHostName() + ":" + backend.getPort() + "/" + backend.getDatabaseName() + "?rewriteBatchedStatements=true&zeroDateTimeBehavior=convertToNull";
+         case RDBMSBackendMetaData.VENDOR_H2 -> "jdbc:h2:" + backend.getHostName() + ":" + backend.getDatabaseName() + ";MODE=MySQL;DB_CLOSE_DELAY=-1";
          default -> throw new IllegalArgumentException("Unsupported rdbms backend vendor: " + backend.getVendor());
       };
    }

qqq-backend-module-rdbms/src/main/java/com/kingsrook/qqq/backend/module/rdbms/model/metadata/RDBMSBackendMetaData.java

@@ -49,6 +49,13 @@ public class RDBMSBackendMetaData extends QBackendMetaData
 
    private RDBMSBackendMetaData readOnlyBackendMetaData;
 
+   ///////////////////////////////////////////////////////////
+   // define well-known (and fully supported) vendor values //
+   ///////////////////////////////////////////////////////////
+   public static final String VENDOR_MYSQL        = "mysql";
+   public static final String VENDOR_H2           = "h2";
+   public static final String VENDOR_AURORA_MYSQL = "aurora-mysql";
+
 
 
    /*******************************************************************************

qqq-middleware-api/src/main/java/com/kingsrook/qqq/api/actions/GetTableApiFieldsAction.java

@@ -25,9 +25,11 @@ package com.kingsrook.qqq.api.actions;
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.stream.Collectors;
+import java.util.Set;
 import com.kingsrook.qqq.api.model.APIVersion;
 import com.kingsrook.qqq.api.model.APIVersionRange;
 import com.kingsrook.qqq.api.model.actions.GetTableApiFieldsInput;
@@ -76,7 +78,27 @@ public class GetTableApiFieldsAction extends AbstractQActionFunction<GetTableApi
    {
       if(!fieldMapCache.containsKey(apiNameVersionAndTableName))
       {
-         Map<String, QFieldMetaData> map = getTableApiFieldList(apiNameVersionAndTableName).stream().collect(Collectors.toMap(f -> (ApiFieldMetaData.getEffectiveApiFieldName(apiNameVersionAndTableName.apiName(), f)), f -> f));
+         List<QFieldMetaData>        tableApiFieldList   = getTableApiFieldList(apiNameVersionAndTableName);
+         Map<String, QFieldMetaData> map                 = new LinkedHashMap<>();
+         Set<String>                 duplicateFieldNames = new HashSet<>();
+         for(QFieldMetaData qFieldMetaData : tableApiFieldList)
+         {
+            String effectiveApiFieldName = ApiFieldMetaData.getEffectiveApiFieldName(apiNameVersionAndTableName.apiName(), qFieldMetaData);
+            if(map.containsKey(effectiveApiFieldName))
+            {
+               duplicateFieldNames.add(effectiveApiFieldName);
+            }
+            else
+            {
+               map.put(effectiveApiFieldName, qFieldMetaData);
+            }
+         }
+
+         if(!duplicateFieldNames.isEmpty())
+         {
+            throw (new QException("The field names [" + duplicateFieldNames + "] appear in this api table more than once.  (Do you need to exclude a field that is still in the table, but is also marked as removed?)"));
+         }
+
          fieldMapCache.put(apiNameVersionAndTableName, map);
       }
 

qqq-middleware-api/src/main/java/com/kingsrook/qqq/api/model/metadata/tables/ApiTableMetaDataContainer.java

@@ -25,6 +25,14 @@ package com.kingsrook.qqq.api.model.metadata.tables;
 import java.util.LinkedHashMap;
 import java.util.Map;
 import com.kingsrook.qqq.api.ApiSupplementType;
+import com.kingsrook.qqq.api.actions.GetTableApiFieldsAction;
+import com.kingsrook.qqq.api.model.APIVersion;
+import com.kingsrook.qqq.api.model.metadata.ApiInstanceMetaData;
+import com.kingsrook.qqq.api.model.metadata.ApiInstanceMetaDataContainer;
+import com.kingsrook.qqq.backend.core.context.CapturedContext;
+import com.kingsrook.qqq.backend.core.context.QContext;
+import com.kingsrook.qqq.backend.core.instances.QInstanceValidator;
+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.tables.QSupplementalTableMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
@@ -36,6 +44,8 @@ import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
  *******************************************************************************/
 public class ApiTableMetaDataContainer extends QSupplementalTableMetaData
 {
+   private static final QLogger LOG = QLogger.getLogger(ApiTableMetaDataContainer.class);
+
    private Map<String, ApiTableMetaData> apis;
 
 
@@ -172,4 +182,51 @@ public class ApiTableMetaDataContainer extends QSupplementalTableMetaData
       return (this);
    }
 
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Override
+   public void validate(QInstance qInstance, QTableMetaData tableMetaData, QInstanceValidator qInstanceValidator)
+   {
+      super.validate(qInstance, tableMetaData, qInstanceValidator);
+
+      ////////////////////////////////////////
+      // iterate over apis this table is in //
+      ////////////////////////////////////////
+      for(String apiName : CollectionUtils.nonNullMap(apis).keySet())
+      {
+         ApiInstanceMetaData apiInstanceMetaData = ApiInstanceMetaDataContainer.of(qInstance).getApis().get(apiName);
+
+         //////////////////////////////////////////////////
+         // iterate over supported versions for this api //
+         //////////////////////////////////////////////////
+         for(APIVersion version : apiInstanceMetaData.getSupportedVersions())
+         {
+            CapturedContext capturedContext = QContext.capture();
+            try
+            {
+               QContext.setQInstance(qInstance);
+
+               ///////////////////////////////////////////////////////////////////////////////////////////////////
+               // try to get the field-map for this table.  note that this will (implicitly) throw an exception //
+               // if we have the same field name more than once, which can happen if a field is both in the     //
+               // removed-list and the table's normal field list.                                               //
+               ///////////////////////////////////////////////////////////////////////////////////////////////////
+               GetTableApiFieldsAction.getTableApiFieldMap(new GetTableApiFieldsAction.ApiNameVersionAndTableName(apiName, version.toString(), tableMetaData.getName()));
+            }
+            catch(Exception e)
+            {
+               String message = "Error validating ApiTableMetaData for table: " + tableMetaData.getName() + ", api: " + apiName + ", version: " + version;
+               LOG.warn(message, e);
+               qInstanceValidator.getErrors().add(message + ": " + e.getMessage());
+            }
+            finally
+            {
+               QContext.init(capturedContext);
+            }
+         }
+      }
+   }
 }

qqq-middleware-picocli/src/test/java/com/kingsrook/qqq/frontend/picocli/QPicoCliImplementationTest.java

@@ -70,6 +70,7 @@ class QPicoCliImplementationTest
    @BeforeEach
    public void beforeEach() throws Exception
    {
+      System.setProperty("picocli.ansi", "false");
       TestUtils.primeTestDatabase();
       QContext.init(TestUtils.defineInstance(), new QSession());
    }

qqq-sample-project/pom.xml

@@ -68,7 +68,7 @@
       <dependency>
          <groupId>com.kingsrook.qqq</groupId>
          <artifactId>qqq-frontend-material-dashboard</artifactId>
-         <version>0.20.0-20240418.180316-42</version>
+         <version>0.20.0</version>
       </dependency>
       <dependency>
          <groupId>com.h2database</groupId>