Merge branch 'rel/0.25.0'

Feature/string utils safe equals ignore case

.circleci/config.yml

@@ -2,6 +2,7 @@ version: 2.1
 
 orbs:
   localstack: localstack/platform@2.1
+  browser-tools: circleci/browser-tools@1.4.7
 
 commands:
   store_jacoco_site:
@@ -38,6 +39,8 @@ commands:
       - restore_cache:
           keys:
             - v1-dependencies-{{ checksum "pom.xml" }}
+      - browser-tools/install-chrome
+      - browser-tools/install-chromedriver
       - run:
           name: Write .env
           command: |
@@ -127,14 +130,9 @@ commands:
           command: |
             cd docs
             asciidoctor -a docinfo=shared index.adoc
-
-  upload_docs_site:
-    steps:
-      - run:
-          name: scp html to justinsgotskinnylegs.com
-          command: |
-            cd docs
-            scp index.html dkelkhoff@45.79.44.221:/mnt/first-volume/dkelkhoff/nginx/html/justinsgotskinnylegs.com/qqq-docs.html
+      - store_artifacts:
+          path: docs/index.html
+          when: always
 
 jobs:
   mvn_test:
@@ -159,7 +157,6 @@ jobs:
     steps:
       - install_asciidoctor
       - run_asciidoctor
-      - upload_docs_site
 
 workflows:
   test_only:

docs/Introduction.adoc

@@ -91,7 +91,7 @@ And then having a bug in the check permission logic on the _Light Bulb Inventory
 No!
 
 All of the (really important, even though application developers hate doing it) aspects of security - you don't need to write ANY code for dealing with that.
-Just tell QQQ what Authentication provider you want to use (e.g., https://auth0.com/[Auth0]), and - to paraphrase the old https://www.youtube.com/watch?v=YHzM4avGrKI[iMac ad] - there's no step 2.
+Just tell QQQ what Authentication provider you want to use (e.g., OAuth2 or https://auth0.com/[Auth0]), and - to paraphrase the old https://www.youtube.com/watch?v=YHzM4avGrKI[iMac ad] - there's no step 2.
 QQQ just does it.
 
 ''''
@@ -136,17 +136,13 @@ This speaks to the fact that this "code" is not executable code - but rather is
 **** The Filter button in the Query Screen will present a menu listing all fields from the table for the user to build ad-hoc queries against the table.
 The data-types specified for the fields (in the meta-data) dictate what operators QQQ allows the user to use against fields (e.g., Strings offer "contains" vs Numbers offer "greater than").
 **** Values for records from the table will be formatted for presentation based on the meta-data (such as a numeric field being shown with commas if it represents a quantity, or formatted as currency).
-...
-
-[start=2]
-. *Meta Data* - declarative code - java object instances (potentially which could be read from `.yaml` files or other data sources in a future version of QQQ), which tell QQQ about the backend systems, tables, processes, reports, widgets, etc, that make up the application.
-For example:
-* Details about the database you are using, and how to connect to it.
-* A database table's name, fields, their types, its keys, and basic business rules (required fields, read-only fields, field lengths).
-* The description of web API - its URL and authentication mechanism.
-* A table/path within a web API, and the fields returned in the JSON at that endpoint.
-* The specification of a custom workflow (process), including what screens are needed, with input & output values, and references to the custom application code for processing the data.
-* Details about a chart that summarizes data from a table for presentation as a dashboard widget.
+* Other kinds of information that you tell QQQ about in the form of meta-data objects includes:
+** Details about the database you are using, and how to connect to it.
+** A database table's name, fields, their types, its keys, and basic business rules (required fields, read-only fields, field lengths).
+** The specification of a custom workflow (process), including what screens are needed, with input & output values, and references to the custom application code for processing the data.
+** Details about a chart that summarizes data from a table for presentation as a dashboard widget.
+** The description of web API - its URL and authentication mechanism.
+** A table/path within a web API, and the fields returned in the JSON at that endpoint.
 // the section below is kinda dumb.  like, it says you have to write application code, but
 // then it just talks about how your app code gets for-free the same shit that QQQ does.
 // it should instead say more about what your custom app code is or does.
@@ -164,7 +160,8 @@ For example:
 // * The multi-threaded, paged producer/consumer pattern used in standard framework actions is how all custom application actions are also invoked.
 // ** For example, the standard QQQ Bulk Edit action uses the same streamed-ETL process that custom application processes can use.
 // Meaning your custom processes can take full advantage of the same complex frontend, middleware, and backend structural pieces, and you can just focus on your unique busines logic needs.
-2. *Application code* - to customize beyond what the QQQ framework does out-of-the box, and to provide application-specific business-logic.
+
+. *Application code* - to customize beyond what the QQQ framework does out-of-the box, and to provide application-specific business-logic.
 QQQ provides its programmers the same classes that it internally uses for record access, resulting in a unified application model.
 For example:
 

docs/actions/QueryAction.adoc

@@ -155,9 +155,9 @@ new QFilterOrderBy()
 ----
 
 ==== QueryJoin
-* `joinTable` - *String, required* - Name of the table that is being joined in to the existing query.
+* `joinTable` - *String, required (though inferrable)* - Name of the table that is being joined in to the existing query.
 ** Will be inferred from *joinMetaData*, if *joinTable* is not set when *joinMetaData* gets set.
-* `baseTableOrAlias` - *String, required* - Name of a table (or an alias) already defined in the query, to which the *joinTable* will be joined.
+* `baseTableOrAlias` - *String, required (though inferrable)* - Name of a table (or an alias) already defined in the query, to which the *joinTable* will be joined.
 ** Will be inferred from *joinMetaData*, if *baseTableOrAlias* is not set when *joinMetaData* gets set (which will only use the leftTableName from the joinMetaData - never an alias).
 * `joinMetaData` - *QJoinMetaData object* - Optional specification of a {link-join} in the current QInstance.
 If not set, will be looked up at runtime based on *baseTableOrAlias* and *joinTable*.
@@ -165,21 +165,78 @@ If not set, will be looked up at runtime based on *baseTableOrAlias* and *joinTa
 * `alias` - *String* - Optional (unless multiple instances of the same table are being joined together, when it becomes required).
 Behavior based on SQL `FROM` clause aliases.
 If given, must be used as the part before the dot in field name specifications throughout the rest of the query input.
-* `select` - *boolean, default: false* - Specify whether fields from the *rightTable* should be selected by the query.
+* `select` - *boolean, default: false* - Specify whether fields from the *joinTable* should be selected by the query.
 If *true*, then the `QRecord` objects returned by this query will have values with corresponding to the (table-or-alias `.` field-name) form.
 * `type` - *Enum of INNER, LEFT, RIGHT, FULL, default: INNER* - specifies the SQL-style type of join being performed.
 
 [source,java]
-.QueryJoin definition examples:
+.Basic QueryJoin usage example:
 ----
-// selecting from an "orderLine" table - then join to its corresponding "order" table
+// selecting from an "orderLine" table, joined to its corresponding (parent) "order" table
 queryInput.withTableName("orderLine");
 queryInput.withQueryJoin(new QueryJoin("order").withSelect(true));
 ...
 queryOutput.getRecords().get(0).getValueBigDecimal("order.grandTotal");
+----
 
+[source,java]
+."V" shaped query - selecting from one parent table, and two children joined to it:
+----
+// TODO this needs verified for accuracy, though is a reasonable starting point as-is
+// selecting from an "order" table, and two children of it, orderLine and customer
+queryInput.withTableName("order");
+queryInput.withQueryJoin(new QueryJoin("orderLine").withSelect(true));
+queryInput.withQueryJoin(new QueryJoin("customer").withSelect(true));
+...
+QRecord joinedRecord = queryOutput.getRecords().get(0);
+joinedRecord.getValueString("orderNo");
+joinedRecord.getValueString("orderLine.sku");
+joinedRecord.getValueString("customer.firstName");
+----
+
+[source,java]
+."Chain" shaped query - selecting from one parent table, a child table, and a grandchild:
+----
+// TODO this needs verified for accuracy, though is a reasonable starting point as-is
+// selecting from an "order" table, with a "customer" child table, and an "address" sub-table
+queryInput.withTableName("order");
+queryInput.withQueryJoin(new QueryJoin("customer").withSelect(true));
+queryInput.withQueryJoin(new QueryJoin("address").withSelect(true));
+...
+QRecord joinedRecord = queryOutput.getRecords().get(0);
+joinedRecord.getValueString("orderNo");
+joinedRecord.getValueString("customer.firstName");
+joinedRecord.getValueString("address.street1");
+----
+
+[source,java]
+.QueryJoin usage example where two tables have two different joins between them:
+----
+// TODO this needs verified for accuracy, though is a reasonable starting point as-is
+// here there's a "fulfillmentPlan" table, which points at the order table (many-to-one,
+// as an order's plan can change over time, and we keep old plans around).
+// This join is named:  fulfillmentPlanJoinOrder
+//
+// The other join is "order" pointing at its current "fulfillmentPlan"
+// This join is named:  orderJoinCurrentFulfillmentPlan
+
+// to select an order along with its current fulfillment plan:
+queryInput.withTableName("order");
+queryInput.withQueryJoin(new QueryJoin(instance.getJoin("orderJoinCurrentFulfillmentPlan"))
+   .withSelect(true));
+
+// to select an order, and all fulfillment plans for an order (1 or more records):
+queryInput.withTableName("order");
+queryInput.withQueryJoin(new QueryJoin(instance.getJoin("fulfillmentPlanJoinOrder"))
+   .withSelect(true));
+----
+
+[source,java]
+.QueryJoin usage example for table with two joins to the same child table, selecting from both:
+----
 // given an "order" table with 2 foreign keys to a customer table (billToCustomerId and shipToCustomerId)
 // Note, we must supply the JoinMetaData to the QueryJoin, to drive what fields to join on in each case.
+// we must also define an alias for each of the QueryJoins
 queryInput.withTableName("order");
 queryInput.withQueryJoins(List.of(
    new QueryJoin(instance.getJoin("orderJoinShipToCustomer")
@@ -190,11 +247,18 @@ queryInput.withQueryJoins(List.of(
        .withSelect(true))));
 ...
 record.getValueString("billToCustomer.firstName")
-   + " placed an order for "
+   + " paid for an order, to be sent to "
    + record.getValueString("shipToCustomer.firstName")
 
 ----
 
+[source,java]
+.Implicit QueryJoin, where unambiguous and required by QQueryFilter
+----
+// TODO finish and verify
+queryInput.withTableName("order");
+----
+
 === QueryOutput
 * `records` - *List of QRecord* - List of 0 or more records that match the query filter.
 ** _Note:  If a *recordPipe* was supplied to the QueryInput, then calling `queryOutput.getRecords()` will result in an `IllegalStateException` being thrown - as the records were placed into the pipe as they were fetched, and cannot all be accessed as a single list._

docs/index.adoc

@@ -6,7 +6,10 @@
 
 include::Introduction.adoc[leveloffset=+1]
 
-== Meta Data
+== Meta Data Production
+include::metaData/MetaDataProduction.adoc[leveloffset=+1]
+
+== Meta Data Types
 // Organizational units
 include::metaData/QInstance.adoc[leveloffset=+1]
 include::metaData/Backends.adoc[leveloffset=+1]
@@ -28,11 +31,9 @@ include::metaData/PermissionRules.adoc[leveloffset=+1]
 
 == Services
 
+include::misc/Javalin.adoc[leveloffset=+1]
 include::misc/ScheduledJobs.adoc[leveloffset=+1]
 
-=== Web server (Javalin)
-#todo#
-
 === API server (OpenAPI)
 #todo#
 

docs/metaData/Fields.adoc

@@ -56,6 +56,37 @@ if the value in the field is longer than the `maxLength`, then one of the follow
 
 ----
 
+===== ValueRangeBehavior
+Used on Numeric fields.  Specifies min and/or max allowed values for the field.
+For each of min and max, the following attributes can be set:
+
+* `minValue` / `maxValue` - the number that is the limit.
+* `minAllowEqualTo` / `maxAllowEqualTo` - boolean (default true).  Controls if < (>) or ≤ (≥).
+* `minBehavior` / `maxBehavior` - enum of `ERROR` (default) or `CLIP`.
+** If `ERROR`, then a value not within the range causes an error, and the value does not get stored.
+** else if `CLIP`, then a value not within the range gets "clipped" to either be the min/max (if allowEqualTo),
+or to the min/max plus/minus the clipAmount
+* `minClipAmount` / `maxClipAmount` - Default 1.  Used when behavior is `CLIP` (only applies when
+not allowEqualTo).
+
+[source,java]
+.Examples of using ValueRangeBehavior
+----
+    new QFieldMetaData("noOfShoes", QFieldType.INTEGER)
+      .withBehavior(new ValueRangeBehavior().withMinValue(0));
+
+    new QFieldMetaData("price", QFieldType.BIG_DECIMAL)
+      .withBehavior(new ValueRangeBehavior()
+         // set the min value to be >= 0, and an error if an input is < 0.
+         .withMinValue(BigDecimal.ZERO)
+         .withMinAllowEqualTo(true)
+         .withMinBehavior(ERROR)
+         // set the max value to be < 100 - but effectively, clip larger values to 99.99
+         // here we use the .withMax() method that takes 4 params vs. calling 4 .withMax*() methods.
+         .withMax(new BigDecimal("100.00"), false, CLIP, new BigDecimal("0.01"))
+    );
+----
+
 ===== DynamicDefaultValueBehavior
 Used to set a dynamic default value to a field when it is being inserted or updated.
 For example, instead of having a hard-coded `defaultValue` specified in the field meta-data,

docs/metaData/MetaDataProduction.adoc

@@ -0,0 +1,413 @@
+[#MetaDataProduction]
+include::../variables.adoc[]
+
+The first thing that an application built using QQQ needs to do is to define its meta data.
+This basically means the construction of a `QInstance` object, which is populated with the
+meta data objects defining the backend(s), tables, processes, possible-value sources, joins,
+authentication provider, etc, that make your application.
+
+There are various styles that can be used for how you define your meta data, and for the
+most part they can be mixed and matched.  They will be presented here based on the historical
+evolution of how they were added to QQQ, where we generally believe that better techniques have
+been added over time.  So, you may wish to skip the earlier techniques, and jump straight to
+the end of this section.  However, it can always be instructive to learn about the past, so,
+read at your own pace.
+
+== Omni-Provider
+At the most basic level, the way to populate a `QInstance` is the simple and direct approach of creating
+one big class, possibly with just one big method, and just doing all the work directly inline there.
+
+This may (clearly) violate several good engineering principles.  However, it does have the benefit of
+being simple - if all of your meta-data is defined in one place, it can be pretty simple to find where
+that place is.  So - especially in a small project, this technique may be worth continuing to consider.
+
+Re: "doing all the work" as mentioned above - what work are we talking about?  At a minimum, we need
+to construct the following meta-data objects, and pass them into our `QInstance`:
+
+* `QAuthenticationMetaData` - how (or if!) users will be authenticated to the application.
+* `QBackendMeataData` - a backend data store.
+* `QTableMetaData` - a table (within the backend).
+* `QAppMetaData` - an organizational unit to present the other elements in a UI.
+
+Here's what a single-method omni-provider could look like:
+
+[source,java]
+.About the simplest possible single-file meta-data provider
+----
+public QInstance defineQInstance()
+{
+    QInstance qInstance = new QInstance();
+
+    qInstance.setAuthentication(new QAuthenticationMetaData()
+       .withName("anonymous")
+       .withType(QAuthenticationType.FULLY_ANONYMOUS));
+
+    qInstance.addBackend(new QBackendMetaData()
+       .withBackendType(MemoryBackendModule.class)
+       .withName("memoryBackend"));
+
+    qInstance.addTable(new QTableMetaData()
+        .withName("myTable")
+        .withPrimaryKeyField("id")
+        .withBackendName("memoryBackend")
+        .withField(new QFieldMetaData("id", QFieldType.INTEGER)));
+
+    qInstance.addApp(new QAppMetaData()
+       .withName("myApp")
+       .withSectionOfChildren(new QAppSection().withName("mySection"),
+          qInstance.getTable("myTable")))
+
+   return (qInstance);
+}
+----
+
+== Multi-method Omni-Provider
+
+The next evolution of meta-data production comes by just applying some basic better-engineering
+principles, and splitting up from a single method that constructs all the things, to at least
+using unique methods to construct each thing, then calling those methods to add their results
+to the QInstance.
+
+[source,java]
+.Multi-method omni- meta-data provider
+----
+public QInstance defineQInstance()
+{
+    QInstance qInstance = new QInstance();
+    qInstance.setAuthentication(defineAuthenticationMetaData());
+    qInstance.addBackend(defineBackendMetaData());
+    qInstance.addTable(defineMyTableMetaData());
+    qInstance.addApp(defineMyAppMetaData(qInstance));
+    return qInstance;
+}
+
+public QAuthenticationMetaData defineAuthenticationMetaData()
+{
+    return new QAuthenticationMetaData()
+       .withName("anonymous")
+       .withType(QAuthenticationType.FULLY_ANONYMOUS);
+}
+
+public QBackendMetaData defineBackendMetaData()
+{
+    return new QBackendMetaData()
+       .withBackendType(MemoryBackendModule.class)
+       .withName("memoryBackend");
+}
+
+// implementations of defineMyTableMetaData() and defineMyAppMetaData(qInstance)
+// left as an exercise for the reader
+----
+
+== Multi-class Providers
+
+Then the next logical evolution would be to put each of these single meta-data producing
+objects into its own class, along with calls to those classes.  This gets us away from the
+"5000 line" single-class, and lets us stop using the word "omni":
+
+[source,java]
+.Multi-class meta-data providers
+----
+public QInstance defineQInstance()
+{
+    QInstance qInstance = new QInstance();
+    qInstance.setAuthentication(new AuthMetaDataProvider().defineAuthenticationMetaData());
+    qInstance.addBackend(new BackendMetaDataProvider().defineBackendMetaData());
+    qInstance.addTable(new MyTableMetaDataProvider().defineTableMetaData());
+    qInstance.addApp(new MyAppMetaDataProvider().defineAppMetaData(qInstance));
+    return qInstance;
+}
+
+public class AuthMetaDataProvider
+{
+    public QAuthenticationMetaData defineAuthenticationMetaData()
+    {
+        return new QAuthenticationMetaData()
+           .withName("anonymous")
+           .withType(QAuthenticationType.FULLY_ANONYMOUS);
+    }
+}
+
+public class BackendMetaDataProvider
+{
+    public QBackendMetaData defineBackendMetaData()
+    {
+        return new QBackendMetaData()
+           .withBackendType(MemoryBackendModule.class)
+           .withName("memoryBackend");
+    }
+}
+
+// implementations of MyTableMetaDataProvider and MyAppMetaDataProvider
+// left as an exercise for the reader
+----
+
+== MetaDataProducerInterface
+
+As the size of your application grows, if you're doing per-object meta-data providers, you may find it
+burdensome, when adding a new object to your instance, to have to write code for it in two places -
+that is - a new class to produce that meta-data object, AND a single line of code to add that object
+to your `QInstance`.  As such, a mechanism exists to let you avoid that line-of-code for adding the object
+to the `QInstance`.
+
+This mechanism involves adding the `MetaDataProducerInterface` to all of your classes that produce a
+meta-data object.  This interface is generic, with a type parameter that will typically be the type of
+meta-data object you are producing, such as `QTableMetaData`, `QProcessMetaData`, or `QWidgetMetaData`,
+(technically, any class which implements `TopLevelMetaData`).  Implementers of the interface are then
+required to override just one method: `T produce(QInstance qInstance) throws QException;`
+
+Once you have your `MetaDataProducerInterface` classes defined, then there's a one-time call needed
+to add all of the objects produced by these classes to your `QInstance` - as shown here:
+
+[source,java]
+.Using MetaDataProducerInterface
+----
+public QInstance defineQInstance()
+{
+    QInstance qInstance = new QInstance();
+    MetaDataProducerHelper.processAllMetaDataProducersInPackage(qInstance,
+      "com.mydomain.myapplication");
+    return qInstance;
+}
+
+public class AuthMetaDataProducer implements MetaDataProducerInterface<QAuthenticationMetaData>
+{
+    @Override
+    public QAuthenticationMetaData produce(QInstance qInstance)
+    {
+        return new QAuthenticationMetaData()
+           .withName("anonymous")
+           .withType(QAuthenticationType.FULLY_ANONYMOUS);
+    }
+}
+
+public class BackendMetaDataProducer implements MetaDataProducerInterface<QBackendMetaData>
+{
+    @Override
+    public QBackendMetaData defineBackendMetaData()
+    {
+        return new QBackendMetaData()
+           .withBackendType(MemoryBackendModule.class)
+           .withName("memoryBackend");
+    }
+}
+
+// implementations of MyTableMetaDataProvider and MyAppMetaDataProvider
+// left as an exercise for the reader
+----
+
+=== MetaDataProducerMultiOutput
+It is worth mentioning, that sometimes it might feel like a bridge that's a bit too far, to make
+every single one of your meta-data objects require its own class.  Some may argue that it's best
+to do it that way - single responsibility principle, etc.  But, if you're producing, say, 5 widgets
+that are all related, and it's only a handful of lines of code for each one, maybe you'd rather
+produce them all in the same class.  Or maybe when you define a table, you'd like to define its
+joins and widgets at the same time.
+
+This approach can be accomplished by making the type argument for your `MetaDataProducerInterface` be
+`MetaDataProducerMultiOutput` - a simple class that just wraps a list of other `MetaDataProducerOutput`
+objects.
+
+[source,java]
+.Returning a MetaDataProducerMultiOutput
+----
+public class MyMultiProducer implements MetaDataProducerInterface<MetaDataProducerMultiOutput>
+{
+    @Override
+    public MetaDataProducerMultiOutput produce(QInstance qInstance)
+    {
+       MetaDataProducerMultiOutput output = new MetaDataProducerMultiOutput();
+
+       output.add(new QPossibleValueSource()...);
+       output.add(new QJoinMetaData()...);
+       output.add(new QJoinMetaData()...);
+       output.add(new QWidgetMetaData()...);
+       output.add(new QTableMetaData()...);
+
+       return (output);
+    }
+}
+----
+
+
+== Aside: TableMetaData with RecordEntities
+At this point, let's take a brief aside to dig deeper into the creation of a `QTableMeta` object.
+Tables, being probably the most important meta-data type in QQQ, have a lot of information that can
+be specified in their meta-data object.
+
+At the same time, if you're writing any custom code in your QQQ application
+(e.g., any processes or table customizers), where you're working with records from tables, you may
+prefer being able to work with entity beans (e.g., java classes with typed getter & setter methods),
+rather than the default object type that QQQ's ORM actions return, the `QRecord`, which carries all
+of its values in a `Map` (where you don't get compile-time checks of field names or data types).
+QQQ has a mechanism for dealing with this - in the form of the `QRecordEntity` class.
+
+So - if you want to build your application using entity beans (which is recommended, for the compile-time
+safety that they provide in custom code), you will be writing a `QRecordEntity` class for each of your tables,
+which will look like:
+
+[source,java]
+.QRecordEntity example
+----
+public class MyTable extends QRecordEntity
+{
+   public static final String TABLE_NAME = "myTable";
+
+   @QField(isEditable = false, isPrimaryKey = true)
+   private Integer id;
+
+   @QField()
+   private String name;
+
+   // no-arg constructor and constructor that takes a QRecord
+   // getters & setters (and optional fluent setters)
+}
+----
+
+The point of introducing this topic here and now is, that a `QRecordEntity` can be used to shortcut to
+defining some of the attributes in a `QTableMetaData` object.  Specifically, in a `MetaDataProducer<QTableMetaData>`
+you may say:
+
+[source,java]
+.QTableMetaDataProducer using a QRecordEntity
+----
+public QTableMetaData produce(QInstance qInstance) throws QExcpetion
+{
+  return new QTableMetaData()
+     .withName(MyTable.TABLE_NAME)
+     .withFieldsFromEntity(MyTable.class)
+     .withBackendName("memoryBackend");
+}
+----
+
+That `withFieldsFromEntity` call is one of the biggest benefits of this technique.  It allows you to avoid defining
+all of the fields in you table in two places (the entity and the table meta-data).
+
+== MetaData Producing Annotations for Entities
+
+If you are using `QRecordEntity` classes that correspond to your tables, then you can take advantage of some
+additional annotations on those classes, to produce more related meta-data objects associated with those tables.
+The point of this is to eliminate boilerplate, and simplify / speed up the process of getting a new table
+built and deployed in your application.
+
+Furthermore, the case can be made that it is beneficial to keep the meta-data definition for a table as close
+as possible to the entity that corresponds to the table.  This enables modifications to the table (e.g., adding
+a new field/column) to only require edits in one java source file, rather than necessarily requiring edits
+in two files.
+
+=== @QMetaDataProducingEntity
+This is an annotation meant to be placed on a `QRecordEntity` subclass, which you would like to be
+processed by an invocation of `MetaDataProducerHelper`, to automatically produce some meta-data
+objects.
+
+This annotation supports:
+
+* Creating table meta-data for the corresponding record entity table. Enabled by setting `produceTableMetaData=true`.
+** One may customize the table meta data that is produced automatically by supplying a class that extends
+`MetaDataCustomizerInterface` in the annotation attribute `tableMetaDataCustomizer`.
+** In addition to (or as an alternative to) the per-table `MetaDataCustomizerInterface` that can be specified
+in `@QMetaDataProducingEntity.tableMetaDataCustomzier`, when an application calls
+`MetaDataProducerHelper.processAllMetaDataProducersInPackage`, an additional `MetaDataCustomizerInterface` can be
+given, to apply a common set of adjustments to all tales being generated by the call.
+* Making a possible-value-source out of the table.  Enabled by setting `producePossibleValueSource=true`.
+* Processing child tables to create joins and childRecordList widgets
+
+=== @ChildTable
+This is an annotation used as a value that goes inside a `@QMetadataProducingEntity` annotation, to define
+child-tables, e.g., for producing joins and childRecordList widgets related to the table defined in the entity class.
+
+==== @ChildJoin
+This is an annotation used as a value inside a `@ChildTable` inside a `@QMetadataProducingEntity` annotation,
+to control the generation of a `QJoinMetaData`, as a `ONE_TO_MANY` type join from the table represented by
+the annotated entity, to the table referenced in the `@ChildTable` annotation.
+
+==== @ChildRecordListWidget
+This is an annotation used as a value that goes inside a `@QMetadataProducingEntity` annotation, to control
+the generation of a QWidgetMetaData - for a ChildRecordList widget.
+
+[source,java]
+.QRecordEntity with meta-data producing annotations and a table MetaDataCustomizer
+----
+@QMetaDataProducingEntity(
+   produceTableMetaData = true,
+   tableMetaDataCustomizer = MyTable.TableMetaDataCustomizer.class,
+   producePossibleValueSource = true,
+   childTables = {
+      @ChildTable(
+         childTableEntityClass = MyChildTable.class,
+         childJoin = @ChildJoin(enabled = true),
+         childRecordListWidget = @ChildRecordListWidget(enabled = true, label = "Children"))
+   }
+)
+public class MyTable extends QRecordEntity
+{
+   public static final String TABLE_NAME = "myTable";
+
+   public static class TableMetaDataCustomizer implements MetaDataCustomizerInterface<QTableMetaData>
+   {
+      @Override
+      public QTableMetaData customizeMetaData(QInstance qInstance, QTableMetaData table) throws QException
+      {
+         String childJoinName = QJoinMetaData.makeInferredJoinName(TABLE_NAME, MyChildTable.TABLE_NAME);
+
+         table
+            .withUniqueKey(new UniqueKey("name"))
+            .withIcon(new QIcon().withName("table_bar"))
+            .withRecordLabelFormat("%s")
+            .withRecordLabelFields("name")
+
+            .withSection(new QFieldSection("identity", new QIcon().withName("badge"), Tier.T1,
+               List.of("id", "name")))
+            // todo additional sections for other fields
+            .withSection(new QFieldSection("children", new QIcon().withName("account_tree"), Tier.T2)
+               .withWidgetName(childJoinName))
+
+            .withExposedJoin(new ExposedJoin()
+               .withLabel("Children")
+               .withJoinPath(List.of(childJoinName))
+               .withJoinTable(MyChildTable.TABLE_NAME));
+
+         return (table);
+      }
+   }
+
+   @QField(isEditable = false, isPrimaryKey = true)
+   private Integer id;
+
+   // remaining fields, constructors, getters & setters left as an exercise for the reader and/or the IDE
+}
+----
+
+The class given in the example above, if processed by the `MetaDataProducerHelper`, would add the following
+meta-data objects to your `QInstance`:
+
+* A `QTableMetaData` named `myTable`, with all fields annotated as `@QField` from the `QRecordEntity` class,
+and with additional attributes as set in the `TableMetaDataCustomizer` inner class.
+* A `QPossibleValueSource` named `myTable`, of type `TABLE`, with `myTable` as its backing table.
+* A `QJoinMetaData` named `myTableJoinMyChildTable`, as a `ONE_TO_MANY` type, between those two tables.
+* A `QWidgetMetaData` named `myTableJoinMyChildTable`, as a `CHILD_RECORD_LIST` type, that will show a list of
+records from `myChildTable` as a widget, when viewing a record from `myTable`.
+
+== Other MetaData Producing Annotations
+
+Similar to these annotations for a `RecordEntity`, a similar one exists for a `PossibleValueEnum` class,
+to automatically write the meta-data to use that enum as a possible value source in your application:
+
+=== @QMetaDataProducingPossibleValueEnum
+This is an annotation to go on a `PossibleValueEnum` class, which you would like to be
+processed by MetaDataProducerHelper, to automatically produce a PossibleValueSource meta-data
+based on the enum.
+
+[source,java]
+.PossibleValueEnum with meta-data producing annotation
+----
+@QMetaDataProducingPossibleValueEnum(producePossibleValueSource = true)
+public enum MyOptionsEnum implements PossibleValueEnum<Integer>
+{
+   // values and methods left as exercise for reader
+}
+----
+The enum given in the example above, if processed by the `MetaDataProducerHelper`, would add the following
+meta-data object to your `QInstance`:
+
+* A `QPossibleValueSource` named `MyOptionsEnum`, of type `ENUM`, with `MyOptionsEnum` as its backing enum.

docs/metaData/Processes.adoc

@@ -38,6 +38,13 @@ See {link-permissionRules} for details.
 *** 1) by a single call to `.withStepList(List<QStepMetaData>)`, which internally adds each step into the `steps` map.
 *** 2) by multiple calls to `.addStep(QStepMetaData)`, which adds a step to both the `stepList` and `steps` map.
 ** If a process also needs optional steps (for a <<_custom_process_flow>>), they should be added by a call to `.addOptionalStep(QStepMetaData)`, which only places them in the `steps` map.
+* `stepFlow` - *enum, default LINEAR* - specifies the the flow-control logic between steps.  Possible values are:
+** `LINEAR` - steps are executed in-order, through the `stepList`.
+A backend step _can_ customize the `nextStepName` or re-order the `stepList`, if needed.
+In a frontend step, a user may be given the option to go _back_ to a previous step as well.
+** `STATE_MACHINE` - steps are executed as a Fine State Machine, starting with the first step in `stepList`,
+but then proceeding based on the `nextStepName` specified by the previous step.
+Thus allowing much more flexible flows.
 * `schedule` - *<<QScheduleMetaData>>* - set up the process to run automatically on the specified schedule.
 See below for details.
 * `minInputRecords` - *Integer* - #not used...#
@@ -67,6 +74,11 @@ For processes with a user-interface, they must define one or more "screens" in t
 * `formFields` - *List of String* - list of field names used by the screen as form-inputs.
 * `viewFields` - *List of String* - list of field names used by the screen as visible outputs.
 * `recordListFields` - *List of String* - list of field names used by the screen in a record listing.
+* `format` - *Optional String* - directive for a frontend to use specialized formatting for the display of the process.
+** Consult frontend documentation for supported values and their meanings.
+* `backStepName` - *Optional String* - For processes using `LINEAR` flow, if this value is given,
+then the frontend should offer a control that the user can take (e.g., a button) to move back to an
+earlier step in the process.
 
 ==== QFrontendComponentMetaData
 
@@ -90,10 +102,13 @@ Expects a process value named `html`.
 Expects process values named `downloadFileName` and `serverFilePath`.
 ** `GOOGLE_DRIVE_SELECT_FOLDER` - Special form that presents a UI from Google Drive, where the user can select a folder (e.g., as a target for uploading files in a subsequent backend step).
 ** `BULK_EDIT_FORM` - For use by the standard QQQ Bulk Edit process.
+** `BULK_LOAD_FILE_MAPPING_FORM`, `BULK_LOAD_VALUE_MAPPING_FORM`, or `BULK_LOAD_PROFILE_FORM` - For use by the standard QQQ Bulk Load process.
 ** `VALIDATION_REVIEW_SCREEN` - For use by the QQQ Streamed ETL With Frontend process family of processes.
 Displays a component prompting the user to run full validation or to skip it, or, if full validation has been ran, then showing the results of that validation.
 ** `PROCESS_SUMMARY_RESULTS` - For use by the QQQ Streamed ETL With Frontend process family of processes.
 Displays the summary results of running the process.
+** `WIDGET` - Render a QQQ Widget.
+Requires that `widgetName` be given as a value for the component.
 ** `RECORD_LIST` - _Deprecated.
 Showed a grid with a list of records as populated by the process._
 * `values` - *Map of String → Serializable* - Key=value pairs, with different expectations based on the component's `type`.
@@ -116,6 +131,27 @@ It can be used, however, for example, to cause a `defaultValue` to be applied to
 It can also be used to cause the process to throw an error, if a field is marked as `isRequired`, but a value is not present.
 ** `recordListMetaData` - *RecordListMetaData object* - _Not used at this time._
 
+==== QStateMachineStep
+
+Processes that use `flow = STATE_MACHINE` should use process steps of type `QStateMachineStep`.
+
+A common pattern seen in state-machine processes, is that they will present a frontend-step to a user,
+then always run a given backend-step in response to that screen which the user submitted.
+Inside that backend-step, custom application logic will determine the next state to go to,
+which is typically another frontend-step (which would then submit data to its corresponding backend-step,
+and continue the FSM).
+
+To help facilitate this pattern, factory methods exist on `QStateMachineStep`,
+for constructing the commonly-expected types of state-machine steps:
+
+* `frontendThenBackend(name, frontendStep, backendStep)` - for the frontend-then-backend pattern described above.
+* `backendOnly(name, backendStep)` - for a state that only has a backend step.
+This might be useful as a “reset” step, to run before restarting a state-loop.
+* `frontendOnly(name, frontendStep)` - for a state that only has a frontend step,
+which would always be followed by another state, which must be specified as the `defaultNextStepName`
+on the `QStateMachineStep`.
+
+
 ==== BasepullConfiguration
 
 A "Basepull" process is a common pattern where an application needs to perform some action on all new (or updated) records from a particular data source.
@@ -218,12 +254,10 @@ But for some cases, doing page-level transactions can reduce long-transactions a
 * `withSchedule(QScheduleMetaData schedule)` - Add a <<QScheduleMetaData>> to the process.
 
 [#_custom_process_flow]
-==== Custom Process Flow
-As referenced in the definition of the <<_QProcessMetaData_Properties,QProcessMetaData Properties>>, by default, a process
-will execute each of its steps in-order, as defined in the `stepList` property.
-However, a Backend Step can customize this flow #todo - write more clearly here...
-
-There are generally 2 method to call (in a `BackendStep`) to do a dynamic flow:
+==== How to customize a Linear process flow
+As referenced in the definition of the <<_QProcessMetaData_Properties,QProcessMetaData Properties>>, by default,
+(with `flow = LINEAR`) a process will execute each of its steps in-order, as defined in the `stepList` property.
+However, a Backend Step can customize this flow as follows:
 
 * `RunBackendStepOutput.setOverrideLastStepName(String stepName)`
 ** QQQ's `RunProcessAction` keeps track of which step it "last" ran, e.g., to tell it which one to run next.
@@ -239,7 +273,7 @@ does need to be found in the new `stepNameList` - otherwise, the framework will
 for figuring out where to go next.
 
 [source,java]
-.Example of a defining process that can use a flexible flow:
+.Example of a defining process that can use a customized linear flow:
 ----
 // for a case like this, it would be recommended to define all step names in constants:
 public final static String STEP_START = "start";
@@ -324,4 +358,21 @@ public static class StartStep implements BackendStep
 }
 ----
 
+[#_process_back]
+==== How to allow a process to go back
+
+The simplest option to allow a process to present a "Back" button to users,
+thus allowing them to move backward through a process
+(e.g., from a review screen back to an earlier input screen), is to set the property `backStepName`
+on a `QFrontendStepMetaData`.
+
+If the step that is executed after the user hits "Back" is a backend step, then within that
+step, `runBackendStepInput.getIsStepBack()` will return `true` (but ONLY within that first step after
+the user hits "Back").  It may be necessary within individual processes to be aware that the user
+has chosen to go back, to reset certain values in the process's state.
+
+Alternatively, if a frontend step's "Back" behavior needs to be dynamic (e.g., sometimes not available,
+or sometimes targeting different steps in the process), then in a backend step that runs before the
+frontend step, a call to `runBackendStepOutput.getProcessState().setBackStepName()` can be made,
+to customize the value which would otherwise come from the `QFrontendStepMetaData`.
 

docs/metaData/QInstance.adoc

@@ -29,11 +29,21 @@ service.routes(qJavalinImplementation.getRoutes());
 service.start();
 ----
 
-*QBackendMetaData Setup Methods:*
+*QInstance Setup:*
 
 These are the methods that one is most likely to use when setting up (defining) a `QInstance` object:
 
-* asdf
+* `add(TopLevelMetaDataInterface metaData)` - Generic method that takes most of the meta-data subtypes that can be added
+to an instance, such as `QBackendMetaData`, `QTableMetaData`, `QProcessMetaData`, etc.
+There are also type-specific methods (e.g., `addTable`, `addProcess`, etc), which one can call instead - this would just
+be a matter of personal preference.
 
-*QBackendMetaData Usage Methods:*
+*QInstance Usage:*
 
+Generally you will set up a `QInstance` in your application's startup flow, and then place it in the server (e.g., javalin).
+But, if, during application-code runtime, you need access to any of the meta-data in the instance, you access it
+via the `QContext` object's static `getInstance()` method.  This can be useful, for example, to get a list of the defined
+tables in the application, or fields in a table, or details about a field, etc.
+
+It is generally considered risky and/or not a good idea at all to modify the `QInstance` after it has been validated and
+a server is running.  Future versions of QQQ may in fact restrict modifications to the instance after validation.

docs/misc/Javalin.adoc

@@ -0,0 +1,109 @@
+== QQQ Middleware:  Javalin web server
+include::../variables.adoc[]
+
+QQQ provides a standard implementation of a middleware layer - that is - code that exists between the
+QQQ backend and user interface.  This implementation is a web server built using the https://javalin.io/[Javalin framework],
+packaged and deployed in the `qqq-middleware-javalin` maven module
+
+The de facto way to create a QQQ application server is to write a class which uses an instance of one of the
+subclasses of `QApplicationJavalinServer`.
+
+For example, if your application metadata is defined in a directory of yaml files, your server class could be implemented as:
+
+[source,java]
+.ConfigFileBasedQQQApplication usage example
+----
+public static void main(String[] args)
+{
+   try
+   {
+      String path = "src/main/resources/metadata";
+      ConfigFilesBasedQQQApplication application = new ConfigFilesBasedQQQApplication(path);
+      QApplicationJavalinServer javalinServer = new QApplicationJavalinServer(application);
+      javalinServer.start();
+   }
+   catch(Exception e)
+   {
+      LOG.error("Failed to start javalin server.  See stack trace for details.", e);
+   }
+}
+----
+
+A similar class exists if your metadata is produced by a package of Java MetaDataProducer objects:  `MetaDataProducerBasedQQQApplication`.
+
+=== QApplicationJavalinServer
+This class provides the bridge between your QQQ Application (e.g., your metadata) and the QQQ Middleware layer
+served by a Javalin web server.  It has several properties to control behaviors:
+
+* `Integer port` - (default `8000`) - port to use for serving HTTP.
+* `boolean serveFrontendMaterialDashboard` - (default `true`) whether to serve the javascript frontend provided
+in the maven artifact `qqq-frontend-material-dashboard`.
+* `boolean serveLegacyUnversionedMiddlewareAPI` - (default `true`) whether to serve a version the original implementation
+of the QQQ middleware, which current version of `qqq-frontend-material-dashboard` are compatible with.
+* `List<AbstractMiddlewareVersion> middlewareVersionList` - (default contains `MiddlewareVersionV1`) - list of
+newer, formally versioned implementations of the QQQ middleware interface to be served.
+* `Consumer<Javalin> javalinConfigurationCustomizer` - (default `null`) - optional hook to customize the
+javalin service object before it is started.
+* `List<QJavalinRouteProviderInterface> additionalRouteProviders` - (default `null`) - list of fully custom
+implementations of `QJavalinRouteProviderInterface`, to add additional endpoints to the javalin server.
+** _Note, you may first want to consider using JavalinRouteProviderMetaData instead - see below._
+* `QJavalinMetaData javalinMetaData` - (default `null`) - optional alternative place to define `JavalinMetaData` (vs.
+defining it in the `QInstance`). _Note that if it is set in both places, the one in the QApplicationJavalinServer
+is used._
+
+=== JavalinMetaData
+Certain behaviors of a QQQ Javalin server are configured in a declarative manner by adding a `QJavalinMetaData`
+object to the `supplementalMetaData` in your `QInstance` (or, as mentioned above, by setting it directly on the
+`QApplicationJavalinServer`):
+
+* `List<JavalinRouteProviderMetaData> routeProviders` - (default `null`) optional list of custom route providers to
+add to the Javalin server.  See below for details.
+* `String uploadedFileArchiveTableName` - (default `null`) - reference to a QQQ Table in your application instance,
+needed to support the Bulk Load process, as well as any other processes which need to accept an uploaded file
+as input.
+* `boolean loggerDisabled` - (default `false`)
+* `Function<QJavalinAccessLogger.LogEntry, Boolean> logFilter` - (default `null`)
+* `boolean queryWithoutLimitAllowed` - (default `false`)
+* `Integer queryWithoutLimitDefault` - (default `1000`)
+* `Level queryWithoutLimitLogLevel` - (default `INFO`)
+
+==== JavalinRouteProviderMetaData
+This type of metadata allows you to add additional http route providers to your Javalin instance, e.g., for
+serving static files or for running custom code from your application (in the form of QQQ Processes) to respond
+to HTTP requests.
+
+* `String hostedPath` - (required)
+* `String fileSystemPath` - (required for a static router)
+* `String processName` - required for a dynamic, process-based router.  Must be a process name within the QQQ Instance.
+See below for additional details
+* `List<String> methods` - required list of HTTP methods (verbs) that are served by the route provider
+* `QCodeReference routeAuthenticator - Optional reference to a class that implements `RouteAuthenticatorInterface`,
+to provide security authentication to all requests handled by the route provider.
+** A default implementation is provided as `SimpleRouteAuthenticator`, which requires that a user session be present
+to access paths served by the route provider.
+
+===== Process-based route provider processes
+If you define a `JavalinRouteProviderMetaData` with a `processName` (e.g., to serve dynamic HTTP responses from your javalin
+server), the process that you implement will be called to respond to any HTTP requests received by the javalin
+server which match the `hostedPath` and `methods` that are specified in the metadata.
+
+The QQQ javalin server will marshal request data from the javalin context into the process's payload, conforming to
+the shape of the `ProcessBasedRouterPayload` class.  Similarly, the http response will be built by taking values from
+the process's output/state conforming to the fields in that class.  As such, it is recommended to use a
+`ProcessBasedRouterPayload`  instance, as show in this example:
+
+[source,java]
+.Process-based router usage example (including ProcessBasedRouterPayload)
+----
+public class MyDynamicSiteProcessStep implements BackendStep
+{
+   @Override
+   public void run(RunBackendStepInput input, RunBackendStepOutput output) throws QException
+   {
+      ProcessBasedRouterPayload payload = input.getProcessPayload(ProcessBasedRouterPayload.class);
+      String path = payload.getPath();
+      payload.setResponseString("You requested: " + path);
+      output.setProcessPayload(payload);
+   }
+}
+----

pom.xml

@@ -34,6 +34,7 @@
       <module>qqq-backend-module-api</module>
       <module>qqq-backend-module-filesystem</module>
       <module>qqq-backend-module-rdbms</module>
+      <module>qqq-backend-module-sqlite</module>
       <module>qqq-backend-module-mongodb</module>
       <module>qqq-language-support-javascript</module>
       <module>qqq-openapi</module>
@@ -47,7 +48,7 @@
    </modules>
 
    <properties>
-      <revision>0.24.0-SNAPSHOT</revision>
+      <revision>0.25.0</revision>
 
       <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
       <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>

qqq-backend-core/pom.xml

@@ -65,7 +65,11 @@
          <artifactId>aws-java-sdk-secretsmanager</artifactId>
          <version>1.12.385</version>
       </dependency>
-
+      <dependency>
+         <groupId>com.ibm.icu</groupId>
+         <artifactId>icu4j</artifactId>
+         <version>77.1</version>
+      </dependency>
       <dependency>
          <groupId>com.fasterxml.jackson.core</groupId>
          <artifactId>jackson-databind</artifactId>
@@ -100,7 +104,12 @@
       <dependency>
          <groupId>org.dhatim</groupId>
          <artifactId>fastexcel</artifactId>
-         <version>0.12.15</version>
+         <version>0.18.4</version>
+      </dependency>
+      <dependency>
+         <groupId>org.dhatim</groupId>
+         <artifactId>fastexcel-reader</artifactId>
+         <version>0.18.4</version>
       </dependency>
       <dependency>
          <groupId>org.apache.poi</groupId>
@@ -112,10 +121,24 @@
          <artifactId>poi-ooxml</artifactId>
          <version>5.2.5</version>
       </dependency>
+
+      <!-- adding to help FastExcel -->
+      <dependency>
+         <groupId>commons-io</groupId>
+         <artifactId>commons-io</artifactId>
+         <version>2.16.0</version>
+      </dependency>
+
+      <dependency>
+         <groupId>com.nimbusds</groupId>
+         <artifactId>oauth2-oidc-sdk</artifactId>
+         <version>11.23.1</version>
+      </dependency>
+
       <dependency>
          <groupId>com.auth0</groupId>
          <artifactId>auth0</artifactId>
-         <version>2.1.0</version>
+         <version>2.18.0</version>
       </dependency>
       <dependency>
          <groupId>com.auth0</groupId>
@@ -125,12 +148,12 @@
       <dependency>
          <groupId>com.auth0</groupId>
          <artifactId>jwks-rsa</artifactId>
-         <version>0.22.0</version>
+         <version>0.22.1</version>
       </dependency>
       <dependency>
          <groupId>io.github.cdimascio</groupId>
-         <artifactId>java-dotenv</artifactId>
-         <version>5.2.2</version>
+         <artifactId>dotenv-java</artifactId>
+         <version>3.2.0</version>
       </dependency>
       <dependency>
          <groupId>org.apache.velocity</groupId>
@@ -138,16 +161,21 @@
          <version>2.3</version>
       </dependency>
 
-      <!-- the next 2 deps are for html to pdf - per https://www.baeldung.com/java-html-to-pdf -->
+      <!-- the next 3 deps are for html to pdf -->
       <dependency>
          <groupId>org.jsoup</groupId>
          <artifactId>jsoup</artifactId>
          <version>1.15.3</version>
       </dependency>
       <dependency>
-         <groupId>org.xhtmlrenderer</groupId>
-         <artifactId>flying-saucer-pdf-openpdf</artifactId>
-         <version>9.1.22</version>
+         <groupId>com.openhtmltopdf</groupId>
+         <artifactId>openhtmltopdf-core</artifactId>
+         <version>1.0.10</version>
+      </dependency>
+      <dependency>
+         <groupId>com.openhtmltopdf</groupId>
+         <artifactId>openhtmltopdf-pdfbox</artifactId>
+         <version>1.0.10</version>
       </dependency>
 
       <!-- the next 3 deps are being added for google drive support -->

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

@@ -186,7 +186,7 @@ public class AsyncRecordPipeLoop
 
       if(recordCount > 0)
       {
-         LOG.info("End of job summary", logPair("recordCount", recordCount), logPair("jobName", jobName), logPair("millis", endTime - jobStartTime), logPair("recordsPerSecond", 1000d * (recordCount / (.001d + (endTime - jobStartTime)))));
+         LOG.debug("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/audits/AuditAction.java

@@ -44,6 +44,7 @@ import com.kingsrook.qqq.backend.core.model.actions.tables.get.GetOutput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.insert.InsertInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.insert.InsertOutput;
 import com.kingsrook.qqq.backend.core.model.data.QRecord;
+import com.kingsrook.qqq.backend.core.model.metadata.security.MultiRecordSecurityLock;
 import com.kingsrook.qqq.backend.core.model.metadata.security.RecordSecurityLock;
 import com.kingsrook.qqq.backend.core.model.metadata.security.RecordSecurityLockFilters;
 import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
@@ -173,26 +174,53 @@ public class AuditAction extends AbstractQActionFunction<AuditInput, AuditOutput
       Map<String, Serializable> securityKeyValues = new HashMap<>();
       for(RecordSecurityLock recordSecurityLock : RecordSecurityLockFilters.filterForReadLocks(CollectionUtils.nonNullList(table.getRecordSecurityLocks())))
       {
-         Serializable keyValue = record == null ? null : record.getValue(recordSecurityLock.getFieldName());
-
-         if(keyValue == null && oldRecord.isPresent())
-         {
-            LOG.debug("Table with a securityLock, but value not found in field", logPair("table", table.getName()), logPair("field", recordSecurityLock.getFieldName()));
-            keyValue = oldRecord.get().getValue(recordSecurityLock.getFieldName());
-         }
-
-         if(keyValue == null)
-         {
-            LOG.debug("Table with a securityLock, but value not found in field", logPair("table", table.getName()), logPair("field", recordSecurityLock.getFieldName()), logPair("oldRecordIsPresent", oldRecord.isPresent()));
-         }
-
-         securityKeyValues.put(recordSecurityLock.getSecurityKeyType(), keyValue);
+         getRecordSecurityKeyValues(table, record, oldRecord, recordSecurityLock, securityKeyValues);
       }
       return securityKeyValues;
    }
 
 
 
+   /***************************************************************************
+    ** recursive implementation of getRecordSecurityKeyValues, for dealing with
+    ** multi-locks
+    ***************************************************************************/
+   private static void getRecordSecurityKeyValues(QTableMetaData table, QRecord record, Optional<QRecord> oldRecord, RecordSecurityLock recordSecurityLock, Map<String, Serializable> securityKeyValues)
+   {
+      //////////////////////////////////////////////////////
+      // special case with recursive call for multi-locks //
+      //////////////////////////////////////////////////////
+      if(recordSecurityLock instanceof MultiRecordSecurityLock multiRecordSecurityLock)
+      {
+         for(RecordSecurityLock subLock : RecordSecurityLockFilters.filterForReadLocks(CollectionUtils.nonNullList(multiRecordSecurityLock.getLocks())))
+         {
+            getRecordSecurityKeyValues(table, record, oldRecord, subLock, securityKeyValues);
+         }
+
+         return;
+      }
+
+      ///////////////////////////////////////////
+      // by default, deal with non-multi locks //
+      ///////////////////////////////////////////
+      Serializable keyValue = record == null ? null : record.getValue(recordSecurityLock.getFieldName());
+
+      if(keyValue == null && oldRecord.isPresent())
+      {
+         LOG.debug("Table with a securityLock, but value not found in field", logPair("table", table.getName()), logPair("field", recordSecurityLock.getFieldName()));
+         keyValue = oldRecord.get().getValue(recordSecurityLock.getFieldName());
+      }
+
+      if(keyValue == null)
+      {
+         LOG.debug("Table with a securityLock, but value not found in field", logPair("table", table.getName()), logPair("field", recordSecurityLock.getFieldName()), logPair("oldRecordIsPresent", oldRecord.isPresent()));
+      }
+
+      securityKeyValues.put(recordSecurityLock.getSecurityKeyType(), keyValue);
+   }
+
+
+
    /*******************************************************************************
     **
     *******************************************************************************/
@@ -218,21 +246,16 @@ public class AuditAction extends AbstractQActionFunction<AuditInput, AuditOutput
                   throw (new QException("Requested audit for an unrecognized table name: " + auditSingleInput.getAuditTableName()));
                }
 
-               ///////////////////////////////////////////////////
-               // validate security keys on the table are given //
-               ///////////////////////////////////////////////////
-               for(RecordSecurityLock recordSecurityLock : RecordSecurityLockFilters.filterForReadLocks(CollectionUtils.nonNullList(table.getRecordSecurityLocks())))
+               ///////////////////////////////////////////////////////
+               // validate security keys on the table are given     //
+               // originally, this case threw...                    //
+               // but i think it's better to record the audit, just //
+               // missing its security key value, then to fail...   //
+               // but, maybe should be configurable, etc...         //
+               ///////////////////////////////////////////////////////
+               if(!validateSecurityKeys(auditSingleInput, table))
                {
-                  if(auditSingleInput.getSecurityKeyValues() == null || !auditSingleInput.getSecurityKeyValues().containsKey(recordSecurityLock.getSecurityKeyType()))
-                  {
-                     ///////////////////////////////////////////////////////
-                     // originally, this case threw...                    //
-                     // but i think it's better to record the audit, just //
-                     // missing its security key value, then to fail...   //
-                     ///////////////////////////////////////////////////////
-                     // throw (new QException("Missing securityKeyValue [" + recordSecurityLock.getSecurityKeyType() + "] in audit request for table " + auditSingleInput.getAuditTableName()));
-                     LOG.info("Missing securityKeyValue in audit request", logPair("table", auditSingleInput.getAuditTableName()), logPair("securityKey", recordSecurityLock.getSecurityKeyType()));
-                  }
+                  LOG.debug("Missing securityKeyValue in audit request", logPair("table", auditSingleInput.getAuditTableName()), logPair("auditMessage", auditSingleInput.getMessage()), logPair("recordId", auditSingleInput.getRecordId()));
                }
 
                ////////////////////////////////////////////////
@@ -310,6 +333,70 @@ public class AuditAction extends AbstractQActionFunction<AuditInput, AuditOutput
 
 
 
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   static boolean validateSecurityKeys(AuditSingleInput auditSingleInput, QTableMetaData table)
+   {
+      boolean allAreValid = true;
+      for(RecordSecurityLock recordSecurityLock : RecordSecurityLockFilters.filterForReadLocks(CollectionUtils.nonNullList(table.getRecordSecurityLocks())))
+      {
+         boolean lockIsValid = validateSecurityKeysForLock(auditSingleInput, recordSecurityLock);
+         if(!lockIsValid)
+         {
+            allAreValid = false;
+         }
+      }
+
+      return (allAreValid);
+   }
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   private static boolean validateSecurityKeysForLock(AuditSingleInput auditSingleInput, RecordSecurityLock recordSecurityLock)
+   {
+      if(recordSecurityLock instanceof MultiRecordSecurityLock multiRecordSecurityLock)
+      {
+         boolean allSubLocksAreValid = true;
+         boolean anySubLocksAreValid = false;
+         for(RecordSecurityLock lock : RecordSecurityLockFilters.filterForReadLocks(CollectionUtils.nonNullList(multiRecordSecurityLock.getLocks())))
+         {
+            boolean subLockIsValid = validateSecurityKeysForLock(auditSingleInput, lock);
+            if(subLockIsValid)
+            {
+               anySubLocksAreValid = true;
+            }
+            else
+            {
+               allSubLocksAreValid = false;
+            }
+         }
+
+         if(multiRecordSecurityLock.getOperator().equals(MultiRecordSecurityLock.BooleanOperator.OR))
+         {
+            return (anySubLocksAreValid);
+         }
+         else if(multiRecordSecurityLock.getOperator().equals(MultiRecordSecurityLock.BooleanOperator.AND))
+         {
+            return (allSubLocksAreValid);
+         }
+      }
+      else
+      {
+         if(auditSingleInput.getSecurityKeyValues() == null || !auditSingleInput.getSecurityKeyValues().containsKey(recordSecurityLock.getSecurityKeyType()))
+         {
+            return (false);
+         }
+      }
+
+      return (true);
+   }
+
+
+
    /*******************************************************************************
     **
     *******************************************************************************/

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

@@ -83,7 +83,7 @@ public class RunRecordScriptAutomationHandler extends RecordAutomationHandler
       }
 
       QRecord scriptRevision = queryOutput.getRecords().get(0);
-      LOG.info("Running script against records", logPair("scriptRevisionId", scriptRevision.getValue("id")), logPair("scriptId", scriptRevision.getValue("scriptIdd")));
+      LOG.debug("Running script against records", logPair("scriptRevisionId", scriptRevision.getValue("id")), logPair("scriptId", scriptRevision.getValue("scriptIdd")));
 
       RunAdHocRecordScriptInput input = new RunAdHocRecordScriptInput();
       input.setCodeReference(new AdHocScriptCodeReference().withScriptRevisionRecord(scriptRevision));

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

@@ -649,7 +649,7 @@ public class PollingAutomationPerTableRunner implements Runnable
          input.setRecordList(records);
          input.setAction(action);
 
-         RecordAutomationHandler recordAutomationHandler = QCodeLoader.getRecordAutomationHandler(action);
+         RecordAutomationHandler recordAutomationHandler = QCodeLoader.getAdHoc(RecordAutomationHandler.class, action.getCodeReference());
          recordAutomationHandler.execute(input);
       }
    }

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

@@ -24,17 +24,11 @@ package com.kingsrook.qqq.backend.core.actions.customizers;
 
 import java.lang.reflect.Constructor;
 import java.util.Optional;
-import java.util.function.Function;
-import com.kingsrook.qqq.backend.core.actions.automation.RecordAutomationHandler;
-import com.kingsrook.qqq.backend.core.actions.processes.BackendStep;
-import com.kingsrook.qqq.backend.core.actions.values.QCustomPossibleValueProvider;
-import com.kingsrook.qqq.backend.core.exceptions.QException;
 import com.kingsrook.qqq.backend.core.logging.QLogger;
+import com.kingsrook.qqq.backend.core.model.metadata.code.InitializableViaCodeReference;
 import com.kingsrook.qqq.backend.core.model.metadata.code.QCodeReference;
 import com.kingsrook.qqq.backend.core.model.metadata.code.QCodeType;
-import com.kingsrook.qqq.backend.core.model.metadata.possiblevalues.QPossibleValueSource;
 import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
-import com.kingsrook.qqq.backend.core.model.metadata.tables.automation.TableAutomationAction;
 import com.kingsrook.qqq.backend.core.utils.lambdas.UnsafeFunction;
 import com.kingsrook.qqq.backend.core.utils.memoization.Memoization;
 import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
@@ -43,9 +37,7 @@ import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
 /*******************************************************************************
  ** Utility to load code for running QQQ customizers.
  **
- ** TODO - redo all to go through method that memoizes class & constructor
- ** lookup.  That memoziation causes 1,000,000 such calls to go from ~500ms
- ** to ~100ms.
+ ** That memoization causes 1,000,000 such calls to go from ~500ms to ~100ms.
  *******************************************************************************/
 public class QCodeLoader
 {
@@ -70,84 +62,6 @@ public class QCodeLoader
 
 
 
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   @SuppressWarnings("unchecked")
-   public static <T, R> Function<T, R> getFunction(QCodeReference codeReference)
-   {
-      if(codeReference == null)
-      {
-         return (null);
-      }
-
-      if(!codeReference.getCodeType().equals(QCodeType.JAVA))
-      {
-         ///////////////////////////////////////////////////////////////////////////////////////
-         // todo - 1) support more languages, 2) wrap them w/ java Functions here, 3) profit! //
-         ///////////////////////////////////////////////////////////////////////////////////////
-         throw (new IllegalArgumentException("Only JAVA customizers are supported at this time."));
-      }
-
-      try
-      {
-         Class<?> customizerClass = Class.forName(codeReference.getName());
-         return ((Function<T, R>) customizerClass.getConstructor().newInstance());
-      }
-      catch(Exception e)
-      {
-         LOG.error("Error initializing customizer", e, logPair("codeReference", codeReference));
-
-         //////////////////////////////////////////////////////////////////////////////////////////////////////////
-         // return null here - under the assumption that during normal run-time operations, we'll never hit here //
-         // as we'll want to validate all functions in the instance validator at startup time (and IT will throw //
-         // if it finds an invalid code reference                                                                //
-         //////////////////////////////////////////////////////////////////////////////////////////////////////////
-         return (null);
-      }
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   @SuppressWarnings("unchecked")
-   public static <T extends BackendStep> T getBackendStep(Class<T> expectedType, QCodeReference codeReference)
-   {
-      if(codeReference == null)
-      {
-         return (null);
-      }
-
-      if(!codeReference.getCodeType().equals(QCodeType.JAVA))
-      {
-         ///////////////////////////////////////////////////////////////////////////////////////
-         // todo - 1) support more languages, 2) wrap them w/ java Functions here, 3) profit! //
-         ///////////////////////////////////////////////////////////////////////////////////////
-         throw (new IllegalArgumentException("Only JAVA BackendSteps are supported at this time."));
-      }
-
-      try
-      {
-         Class<?> customizerClass = Class.forName(codeReference.getName());
-         return ((T) customizerClass.getConstructor().newInstance());
-      }
-      catch(Exception e)
-      {
-         LOG.error("Error initializing customizer", e, logPair("codeReference", codeReference));
-
-         //////////////////////////////////////////////////////////////////////////////////////////////////////////
-         // return null here - under the assumption that during normal run-time operations, we'll never hit here //
-         // as we'll want to validate all functions in the instance validator at startup time (and IT will throw //
-         // if it finds an invalid code reference                                                                //
-         //////////////////////////////////////////////////////////////////////////////////////////////////////////
-         return (null);
-      }
-   }
-
-
-
    /*******************************************************************************
     **
     *******************************************************************************/
@@ -177,7 +91,17 @@ public class QCodeLoader
 
          if(constructor.isPresent())
          {
-            return ((T) constructor.get().newInstance());
+            T t = (T) constructor.get().newInstance();
+
+            ////////////////////////////////////////////////////////////////
+            // if the object is initializable, then, well, initialize it! //
+            ////////////////////////////////////////////////////////////////
+            if(t instanceof InitializableViaCodeReference initializableViaCodeReference)
+            {
+               initializableViaCodeReference.initialize(codeReference);
+            }
+
+            return t;
          }
          else
          {
@@ -187,7 +111,7 @@ public class QCodeLoader
       }
       catch(Exception e)
       {
-         LOG.error("Error initializing customizer", e, logPair("codeReference", codeReference));
+         LOG.error("Error initializing codeReference", e, logPair("codeReference", codeReference));
 
          //////////////////////////////////////////////////////////////////////////////////////////////////////////
          // return null here - under the assumption that during normal run-time operations, we'll never hit here //
@@ -198,67 +122,4 @@ public class QCodeLoader
       }
    }
 
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   public static RecordAutomationHandler getRecordAutomationHandler(TableAutomationAction action) throws QException
-   {
-      try
-      {
-         QCodeReference codeReference = action.getCodeReference();
-         if(!codeReference.getCodeType().equals(QCodeType.JAVA))
-         {
-            ///////////////////////////////////////////////////////////////////////////////////////
-            // todo - 1) support more languages, 2) wrap them w/ java Functions here, 3) profit! //
-            ///////////////////////////////////////////////////////////////////////////////////////
-            throw (new IllegalArgumentException("Only JAVA customizers are supported at this time."));
-         }
-
-         Class<?> codeClass  = Class.forName(codeReference.getName());
-         Object   codeObject = codeClass.getConstructor().newInstance();
-         if(!(codeObject instanceof RecordAutomationHandler recordAutomationHandler))
-         {
-            throw (new QException("The supplied code [" + codeClass.getName() + "] is not an instance of RecordAutomationHandler"));
-         }
-         return (recordAutomationHandler);
-      }
-      catch(QException qe)
-      {
-         throw (qe);
-      }
-      catch(Exception e)
-      {
-         throw (new QException("Error getting record automation handler for action [" + action.getName() + "]", e));
-      }
-   }
-
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   public static QCustomPossibleValueProvider getCustomPossibleValueProvider(QPossibleValueSource possibleValueSource) throws QException
-   {
-      try
-      {
-         Class<?> codeClass  = Class.forName(possibleValueSource.getCustomCodeReference().getName());
-         Object   codeObject = codeClass.getConstructor().newInstance();
-         if(!(codeObject instanceof QCustomPossibleValueProvider customPossibleValueProvider))
-         {
-            throw (new QException("The supplied code [" + codeClass.getName() + "] is not an instance of QCustomPossibleValueProvider"));
-         }
-         return (customPossibleValueProvider);
-      }
-      catch(QException qe)
-      {
-         throw (qe);
-      }
-      catch(Exception e)
-      {
-         throw (new QException("Error getting custom possible value provider for PVS [" + possibleValueSource.getName() + "]", e));
-      }
-   }
-
 }

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

@@ -27,6 +27,7 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
+import java.util.Optional;
 import com.kingsrook.qqq.backend.core.context.QContext;
 import com.kingsrook.qqq.backend.core.logging.QLogger;
 import com.kingsrook.qqq.backend.core.model.actions.tables.update.UpdateInput;
@@ -160,4 +161,18 @@ public interface RecordCustomizerUtilityInterface
       return (oldRecordMap);
    }
 
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   static <T extends Serializable> T getValueFromRecordOrOldRecord(String fieldName, QRecord record, Serializable primaryKey, Optional<Map<Serializable, QRecord>> oldRecordMap)
+   {
+      T value = (T) record.getValue(fieldName);
+      if(value == null && primaryKey != null && oldRecordMap.isPresent() && oldRecordMap.get().containsKey(primaryKey))
+      {
+         value = (T) oldRecordMap.get().get(primaryKey).getValue(fieldName);
+      }
+      return value;
+   }
+
 }

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

@@ -22,15 +22,19 @@
 package com.kingsrook.qqq.backend.core.actions.customizers;
 
 
+import java.io.Serializable;
 import java.util.List;
+import java.util.Map;
 import java.util.Optional;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
 import com.kingsrook.qqq.backend.core.logging.QLogger;
+import com.kingsrook.qqq.backend.core.model.actions.AbstractActionInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.QueryOrGetInputInterface;
 import com.kingsrook.qqq.backend.core.model.actions.tables.delete.DeleteInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.insert.InsertInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.update.UpdateInput;
 import com.kingsrook.qqq.backend.core.model.data.QRecord;
+import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
 import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
 
 
@@ -47,7 +51,6 @@ public interface TableCustomizerInterface
 {
    QLogger LOG = QLogger.getLogger(TableCustomizerInterface.class);
 
-
    /*******************************************************************************
     ** custom actions to run after a query (or get!) takes place.
     **
@@ -77,8 +80,15 @@ public interface TableCustomizerInterface
     *******************************************************************************/
    default List<QRecord> preInsert(InsertInput insertInput, List<QRecord> records, boolean isPreview) throws QException
    {
-      LOG.info("A default implementation of preInsert is running...  Probably not expected!", logPair("tableName", insertInput.getTableName()));
-      return (records);
+      try
+      {
+         return (preInsertOrUpdate(insertInput, records, isPreview, Optional.empty()));
+      }
+      catch(NotImplementedHereException e)
+      {
+         LOG.info("A default implementation of preInsert is running...  Probably not expected!", logPair("tableName", insertInput.getTableName()));
+         return (records);
+      }
    }
 
 
@@ -104,8 +114,15 @@ public interface TableCustomizerInterface
     *******************************************************************************/
    default List<QRecord> postInsert(InsertInput insertInput, List<QRecord> records) throws QException
    {
-      LOG.info("A default implementation of postInsert is running...  Probably not expected!", logPair("tableName", insertInput.getTableName()));
-      return (records);
+      try
+      {
+         return (postInsertOrUpdate(insertInput, records, Optional.empty()));
+      }
+      catch(NotImplementedHereException e)
+      {
+         LOG.info("A default implementation of postInsert is running...  Probably not expected!", logPair("tableName", insertInput.getTableName()));
+         return (records);
+      }
    }
 
 
@@ -130,8 +147,15 @@ public interface TableCustomizerInterface
     *******************************************************************************/
    default List<QRecord> preUpdate(UpdateInput updateInput, List<QRecord> records, boolean isPreview, Optional<List<QRecord>> oldRecordList) throws QException
    {
-      LOG.info("A default implementation of preUpdate is running...  Probably not expected!", logPair("tableName", updateInput.getTableName()));
-      return (records);
+      try
+      {
+         return (preInsertOrUpdate(updateInput, records, isPreview, oldRecordList));
+      }
+      catch(NotImplementedHereException e)
+      {
+         LOG.info("A default implementation of preUpdate is running...  Probably not expected!", logPair("tableName", updateInput.getTableName()));
+         return (records);
+      }
    }
 
 
@@ -151,8 +175,15 @@ public interface TableCustomizerInterface
     *******************************************************************************/
    default List<QRecord> postUpdate(UpdateInput updateInput, List<QRecord> records, Optional<List<QRecord>> oldRecordList) throws QException
    {
-      LOG.info("A default implementation of postUpdate is running...  Probably not expected!", logPair("tableName", updateInput.getTableName()));
-      return (records);
+      try
+      {
+         return (postInsertOrUpdate(updateInput, records, oldRecordList));
+      }
+      catch(NotImplementedHereException e)
+      {
+         LOG.info("A default implementation of postUpdate is running...  Probably not expected!", logPair("tableName", updateInput.getTableName()));
+         return (records);
+      }
    }
 
 
@@ -199,4 +230,59 @@ public interface TableCustomizerInterface
       return (records);
    }
 
+
+   /***************************************************************************
+    ** Optional method to override in a customizer that does the same thing for
+    ** both preInsert & preUpdate.
+    ***************************************************************************/
+   default List<QRecord> preInsertOrUpdate(AbstractActionInput input, List<QRecord> records, boolean isPreview, Optional<List<QRecord>> oldRecordList) throws QException
+   {
+      throw NotImplementedHereException.instance;
+   }
+
+
+   /***************************************************************************
+    ** Optional method to override in a customizer that does the same thing for
+    ** both postInsert & postUpdate.
+    ***************************************************************************/
+   default List<QRecord> postInsertOrUpdate(AbstractActionInput input, List<QRecord> records, Optional<List<QRecord>> oldRecordList) throws QException
+   {
+      throw NotImplementedHereException.instance;
+   }
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   default Optional<Map<Serializable, QRecord>> oldRecordListToMap(String primaryKeyField, Optional<List<QRecord>> oldRecordList)
+   {
+      if(oldRecordList.isPresent())
+      {
+         return (Optional.of(CollectionUtils.listToMap(oldRecordList.get(), r -> r.getValue(primaryKeyField))));
+      }
+      else
+      {
+         return (Optional.empty());
+      }
+   }
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   class NotImplementedHereException extends QException
+   {
+      private static NotImplementedHereException instance = new NotImplementedHereException();
+
+
+
+      /***************************************************************************
+       **
+       ***************************************************************************/
+      private NotImplementedHereException()
+      {
+         super("Not implemented here");
+      }
+   }
 }

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

@@ -290,7 +290,18 @@ public abstract class AbstractHTMLWidgetRenderer extends AbstractWidgetRenderer
    /*******************************************************************************
     **
     *******************************************************************************/
+   @Deprecated(since = "call one that doesn't take input param")
    public static String linkRecordEdit(AbstractActionInput input, String tableName, Serializable recordId) throws QException
+   {
+      return linkRecordEdit(tableName, recordId);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public static String linkRecordEdit(String tableName, Serializable recordId) throws QException
    {
       String tablePath = QContext.getQInstance().getTablePath(tableName);
       return (tablePath + "/" + recordId + "/edit");
@@ -317,7 +328,17 @@ public abstract class AbstractHTMLWidgetRenderer extends AbstractWidgetRenderer
    /*******************************************************************************
     **
     *******************************************************************************/
+   @Deprecated(since = "call one that doesn't take input param")
    public static String linkProcessForFilter(AbstractActionInput input, String processName, QQueryFilter filter) throws QException
+   {
+      return linkProcessForFilter(processName, filter);
+   }
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public static String linkProcessForFilter(String processName, QQueryFilter filter) throws QException
    {
       QProcessMetaData process = QContext.getQInstance().getProcess(processName);
       if(process == null)
@@ -337,10 +358,21 @@ public abstract class AbstractHTMLWidgetRenderer extends AbstractWidgetRenderer
 
 
 
+
    /*******************************************************************************
     **
     *******************************************************************************/
+   @Deprecated(since = "call one that doesn't take input param")
    public static String linkProcessForRecord(AbstractActionInput input, String processName, Serializable recordId) throws QException
+   {
+      return linkProcessForRecord(processName, recordId);
+   }
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public static String linkProcessForRecord(String processName, Serializable recordId) throws QException
    {
       QProcessMetaData process   = QContext.getQInstance().getProcess(processName);
       String           tableName = process.getTableName();

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

@@ -37,6 +37,8 @@ import com.kingsrook.qqq.backend.core.actions.values.QValueFormatter;
 import com.kingsrook.qqq.backend.core.context.QContext;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
 import com.kingsrook.qqq.backend.core.exceptions.QNotFoundException;
+import com.kingsrook.qqq.backend.core.instances.QInstanceValidator;
+import com.kingsrook.qqq.backend.core.instances.validation.plugins.QInstanceValidatorPluginInterface;
 import com.kingsrook.qqq.backend.core.logging.QLogger;
 import com.kingsrook.qqq.backend.core.model.actions.tables.count.CountInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.get.GetInput;
@@ -51,12 +53,15 @@ import com.kingsrook.qqq.backend.core.model.actions.widgets.RenderWidgetOutput;
 import com.kingsrook.qqq.backend.core.model.dashboard.widgets.ChildRecordListData;
 import com.kingsrook.qqq.backend.core.model.dashboard.widgets.WidgetType;
 import com.kingsrook.qqq.backend.core.model.data.QRecord;
+import com.kingsrook.qqq.backend.core.model.metadata.QInstance;
 import com.kingsrook.qqq.backend.core.model.metadata.code.QCodeReference;
 import com.kingsrook.qqq.backend.core.model.metadata.dashboard.AbstractWidgetMetaDataBuilder;
 import com.kingsrook.qqq.backend.core.model.metadata.dashboard.QWidgetMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.dashboard.QWidgetMetaDataInterface;
 import com.kingsrook.qqq.backend.core.model.metadata.joins.JoinOn;
 import com.kingsrook.qqq.backend.core.model.metadata.joins.QJoinMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
+import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
 import com.kingsrook.qqq.backend.core.utils.JsonUtils;
 import com.kingsrook.qqq.backend.core.utils.StringUtils;
 import com.kingsrook.qqq.backend.core.utils.ValueUtils;
@@ -83,7 +88,9 @@ public class ChildRecordListRenderer extends AbstractWidgetRenderer
          .withIsCard(true)
          .withCodeReference(new QCodeReference(ChildRecordListRenderer.class))
          .withType(WidgetType.CHILD_RECORD_LIST.getType())
-         .withDefaultValue("joinName", join.getName())));
+         .withDefaultValue("joinName", join.getName())
+         .withValidatorPlugin(new ChildRecordListWidgetValidator())
+      ));
    }
 
 
@@ -168,6 +175,7 @@ public class ChildRecordListRenderer extends AbstractWidgetRenderer
          widgetMetaData.withDefaultValue("manageAssociationName", manageAssociationName);
          return (this);
       }
+
    }
 
 
@@ -194,7 +202,7 @@ public class ChildRecordListRenderer extends AbstractWidgetRenderer
          }
          else if(input.getWidgetMetaData().getDefaultValues().containsKey("maxRows"))
          {
-            maxRows = ValueUtils.getValueAsInteger(input.getWidgetMetaData().getDefaultValues().containsKey("maxRows"));
+            maxRows = ValueUtils.getValueAsInteger(input.getWidgetMetaData().getDefaultValues().get("maxRows"));
          }
 
          //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -299,6 +307,13 @@ public class ChildRecordListRenderer extends AbstractWidgetRenderer
                   }
                }
             }
+
+            if(widgetValues.containsKey("defaultValuesForNewChildRecordsFromParentFields"))
+            {
+               @SuppressWarnings("unchecked")
+               Map<String, String> defaultValuesForNewChildRecordsFromParentFields = (Map<String, String>) widgetValues.get("defaultValuesForNewChildRecordsFromParentFields");
+               widgetData.setDefaultValuesForNewChildRecordsFromParentFields(defaultValuesForNewChildRecordsFromParentFields);
+            }
          }
 
          widgetData.setAllowRecordEdit(BooleanUtils.isTrue(ValueUtils.getValueAsBoolean(input.getQueryParams().get("allowRecordEdit"))));
@@ -313,4 +328,68 @@ public class ChildRecordListRenderer extends AbstractWidgetRenderer
       }
    }
 
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   private static class ChildRecordListWidgetValidator implements QInstanceValidatorPluginInterface<QWidgetMetaDataInterface>
+   {
+
+      /***************************************************************************
+       **
+       ***************************************************************************/
+      @Override
+      public void validate(QWidgetMetaDataInterface widgetMetaData, QInstance qInstance, QInstanceValidator qInstanceValidator)
+      {
+         String prefix = "Widget " + widgetMetaData.getName() + ": ";
+
+         //////////////////////////////////
+         // make sure join name is given //
+         //////////////////////////////////
+         String joinName = ValueUtils.getValueAsString(CollectionUtils.nonNullMap(widgetMetaData.getDefaultValues()).get("joinName"));
+         if(qInstanceValidator.assertCondition(StringUtils.hasContent(joinName), prefix + "defaultValue for joinName must be given"))
+         {
+            ///////////////////////////
+            // make sure join exists //
+            ///////////////////////////
+            QJoinMetaData join = qInstance.getJoin(joinName);
+            if(qInstanceValidator.assertCondition(join != null, prefix + "No join named " + joinName + " exists in the instance"))
+            {
+               //////////////////////////////////////////////////////////////////////////////////
+               // if there's a manageAssociationName, make sure the table has that association //
+               //////////////////////////////////////////////////////////////////////////////////
+               String manageAssociationName = ValueUtils.getValueAsString(widgetMetaData.getDefaultValues().get("manageAssociationName"));
+               if(StringUtils.hasContent(manageAssociationName))
+               {
+                  validateAssociationName(prefix, manageAssociationName, join, qInstance, qInstanceValidator);
+               }
+            }
+         }
+      }
+
+
+
+      /***************************************************************************
+       **
+       ***************************************************************************/
+      private void validateAssociationName(String prefix, String manageAssociationName, QJoinMetaData join, QInstance qInstance, QInstanceValidator qInstanceValidator)
+      {
+         ///////////////////////////////////
+         // make sure join's table exists //
+         ///////////////////////////////////
+         QTableMetaData table = qInstance.getTable(join.getLeftTable());
+         if(table == null)
+         {
+            qInstanceValidator.getErrors().add(prefix + "Unable to validate manageAssociationName, as table [" + join.getLeftTable() + "] on left-side table of join [" + join.getName() + "] does not exist.");
+         }
+         else
+         {
+            if(CollectionUtils.nonNullList(table.getAssociations()).stream().noneMatch(a -> manageAssociationName.equals(a.getName())))
+            {
+               qInstanceValidator.getErrors().add(prefix + "an association named [" + manageAssociationName + "] does not exist on table [" + join.getLeftTable() + "]");
+            }
+         }
+      }
+   }
 }

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

@@ -0,0 +1,251 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2022.  Kingsrook, LLC
+ * 651 N Broad St Ste 205 # 6917 | Middletown DE 19709 | United States
+ * contact@kingsrook.com
+ * https://github.com/Kingsrook/
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.kingsrook.qqq.backend.core.actions.dashboard.widgets;
+
+
+import java.net.URLEncoder;
+import java.nio.charset.Charset;
+import java.util.HashMap;
+import com.kingsrook.qqq.backend.core.actions.tables.CountAction;
+import com.kingsrook.qqq.backend.core.actions.tables.QueryAction;
+import com.kingsrook.qqq.backend.core.actions.values.QValueFormatter;
+import com.kingsrook.qqq.backend.core.context.QContext;
+import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.instances.QInstanceValidator;
+import com.kingsrook.qqq.backend.core.instances.validation.plugins.QInstanceValidatorPluginInterface;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
+import com.kingsrook.qqq.backend.core.model.actions.tables.count.CountInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.FilterUseCase;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QQueryFilter;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryInput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryOutput;
+import com.kingsrook.qqq.backend.core.model.actions.widgets.RenderWidgetInput;
+import com.kingsrook.qqq.backend.core.model.actions.widgets.RenderWidgetOutput;
+import com.kingsrook.qqq.backend.core.model.dashboard.widgets.ChildRecordListData;
+import com.kingsrook.qqq.backend.core.model.dashboard.widgets.WidgetType;
+import com.kingsrook.qqq.backend.core.model.metadata.QInstance;
+import com.kingsrook.qqq.backend.core.model.metadata.code.QCodeReference;
+import com.kingsrook.qqq.backend.core.model.metadata.dashboard.AbstractWidgetMetaDataBuilder;
+import com.kingsrook.qqq.backend.core.model.metadata.dashboard.QWidgetMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.dashboard.QWidgetMetaDataInterface;
+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.JsonUtils;
+import com.kingsrook.qqq.backend.core.utils.StringUtils;
+import com.kingsrook.qqq.backend.core.utils.ValueUtils;
+import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
+
+
+/*******************************************************************************
+ ** Generic widget to display a list of records.
+ **
+ ** Note, closely related to (and copied from ChildRecordListRenderer.
+ ** opportunity to share more code with that in the future??
+ *******************************************************************************/
+public class RecordListWidgetRenderer extends AbstractWidgetRenderer
+{
+   private static final QLogger LOG = QLogger.getLogger(RecordListWidgetRenderer.class);
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public static Builder widgetMetaDataBuilder(String widgetName)
+   {
+      return (new Builder(new QWidgetMetaData()
+         .withName(widgetName)
+         .withIsCard(true)
+         .withCodeReference(new QCodeReference(RecordListWidgetRenderer.class))
+         .withType(WidgetType.CHILD_RECORD_LIST.getType())
+         .withValidatorPlugin(new RecordListWidgetValidator())
+      ));
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public static class Builder extends AbstractWidgetMetaDataBuilder
+   {
+
+      /*******************************************************************************
+       ** Constructor
+       **
+       *******************************************************************************/
+      public Builder(QWidgetMetaData widgetMetaData)
+      {
+         super(widgetMetaData);
+      }
+
+
+
+      /*******************************************************************************
+       **
+       *******************************************************************************/
+      public Builder withLabel(String label)
+      {
+         widgetMetaData.setLabel(label);
+         return (this);
+      }
+
+
+
+      /*******************************************************************************
+       **
+       *******************************************************************************/
+      public Builder withMaxRows(Integer maxRows)
+      {
+         widgetMetaData.withDefaultValue("maxRows", maxRows);
+         return (this);
+      }
+
+
+
+      /*******************************************************************************
+       **
+       *******************************************************************************/
+      public Builder withTableName(String tableName)
+      {
+         widgetMetaData.withDefaultValue("tableName", tableName);
+         return (this);
+      }
+
+
+
+      /*******************************************************************************
+       **
+       *******************************************************************************/
+      public Builder withFilter(QQueryFilter filter)
+      {
+         widgetMetaData.withDefaultValue("filter", filter);
+         return (this);
+      }
+
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   @Override
+   public RenderWidgetOutput render(RenderWidgetInput input) throws QException
+   {
+      try
+      {
+         Integer maxRows = null;
+         if(StringUtils.hasContent(input.getQueryParams().get("maxRows")))
+         {
+            maxRows = ValueUtils.getValueAsInteger(input.getQueryParams().get("maxRows"));
+         }
+         else if(input.getWidgetMetaData().getDefaultValues().containsKey("maxRows"))
+         {
+            maxRows = ValueUtils.getValueAsInteger(input.getWidgetMetaData().getDefaultValues().get("maxRows"));
+         }
+
+         QQueryFilter filter = ((QQueryFilter) input.getWidgetMetaData().getDefaultValues().get("filter")).clone();
+         filter.interpretValues(new HashMap<>(input.getQueryParams()), FilterUseCase.DEFAULT);
+         filter.setLimit(maxRows);
+
+         String         tableName = ValueUtils.getValueAsString(input.getWidgetMetaData().getDefaultValues().get("tableName"));
+         QTableMetaData table     = QContext.getQInstance().getTable(tableName);
+
+         QueryInput queryInput = new QueryInput();
+         queryInput.setTableName(tableName);
+         queryInput.setShouldTranslatePossibleValues(true);
+         queryInput.setShouldGenerateDisplayValues(true);
+         queryInput.setFilter(filter);
+         QueryOutput queryOutput = new QueryAction().execute(queryInput);
+
+         QValueFormatter.setBlobValuesToDownloadUrls(table, queryOutput.getRecords());
+
+         int totalRows = queryOutput.getRecords().size();
+         if(maxRows != null && (queryOutput.getRecords().size() == maxRows))
+         {
+            /////////////////////////////////////////////////////////////////////////////////////
+            // if the input said to only do some max, and the # of results we got is that max, //
+            // then do a count query, for displaying 1-n of <count>                            //
+            /////////////////////////////////////////////////////////////////////////////////////
+            CountInput countInput = new CountInput();
+            countInput.setTableName(tableName);
+            countInput.setFilter(filter);
+            totalRows = new CountAction().execute(countInput).getCount();
+         }
+
+         String tablePath   = QContext.getQInstance().getTablePath(tableName);
+         String viewAllLink = tablePath == null ? null : (tablePath + "?filter=" + URLEncoder.encode(JsonUtils.toJson(filter), Charset.defaultCharset()));
+
+         ChildRecordListData widgetData = new ChildRecordListData(input.getQueryParams().get("widgetLabel"), queryOutput, table, tablePath, viewAllLink, totalRows);
+
+         return (new RenderWidgetOutput(widgetData));
+      }
+      catch(Exception e)
+      {
+         LOG.warn("Error rendering record list widget", e, logPair("widgetName", () -> input.getWidgetMetaData().getName()));
+         throw (e);
+      }
+   }
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   private static class RecordListWidgetValidator implements QInstanceValidatorPluginInterface<QWidgetMetaDataInterface>
+   {
+
+      /***************************************************************************
+       **
+       ***************************************************************************/
+      @Override
+      public void validate(QWidgetMetaDataInterface widgetMetaData, QInstance qInstance, QInstanceValidator qInstanceValidator)
+      {
+         String prefix = "Widget " + widgetMetaData.getName() + ": ";
+
+         //////////////////////////////////////////////
+         // make sure table name is given and exists //
+         //////////////////////////////////////////////
+         QTableMetaData table = null;
+         String tableName = ValueUtils.getValueAsString(CollectionUtils.nonNullMap(widgetMetaData.getDefaultValues()).get("tableName"));
+         if(qInstanceValidator.assertCondition(StringUtils.hasContent(tableName), prefix + "defaultValue for tableName must be given"))
+         {
+            ////////////////////////////
+            // make sure table exists //
+            ////////////////////////////
+            table = qInstance.getTable(tableName);
+            qInstanceValidator.assertCondition(table != null, prefix + "No table named " + tableName + " exists in the instance");
+         }
+
+         ////////////////////////////////////////////////////////////////////////////////////
+         // make sure filter is given and is valid (only check that if table is given too) //
+         ////////////////////////////////////////////////////////////////////////////////////
+         QQueryFilter filter = ((QQueryFilter) widgetMetaData.getDefaultValues().get("filter"));
+         if(qInstanceValidator.assertCondition(filter != null, prefix + "defaultValue for filter must be given") && table != null)
+         {
+            qInstanceValidator.validateQueryFilter(qInstance, prefix, table, filter, null);
+         }
+      }
+
+   }
+}

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

@@ -33,6 +33,7 @@ import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
 /*******************************************************************************
  ** a default implementation of MetaDataFilterInterface, that allows all the things
  *******************************************************************************/
+@Deprecated(since = "migrated to metaDataCustomizer")
 public class AllowAllMetaDataFilter implements MetaDataFilterInterface
 {
 

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

@@ -0,0 +1,92 @@
+/*
+ * 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.metadata;
+
+
+import com.kingsrook.qqq.backend.core.model.actions.metadata.MetaDataInput;
+import com.kingsrook.qqq.backend.core.model.metadata.dashboard.QWidgetMetaDataInterface;
+import com.kingsrook.qqq.backend.core.model.metadata.layout.QAppMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.processes.QProcessMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.reporting.QReportMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
+
+
+/*******************************************************************************
+ ** a default implementation of MetaDataFilterInterface, that is all noop.
+ *******************************************************************************/
+public class DefaultNoopMetaDataActionCustomizer implements MetaDataActionCustomizerInterface
+{
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   @Override
+   public boolean allowTable(MetaDataInput input, QTableMetaData table)
+   {
+      return (true);
+   }
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   @Override
+   public boolean allowProcess(MetaDataInput input, QProcessMetaData process)
+   {
+      return (true);
+   }
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   @Override
+   public boolean allowReport(MetaDataInput input, QReportMetaData report)
+   {
+      return (true);
+   }
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   @Override
+   public boolean allowApp(MetaDataInput input, QAppMetaData app)
+   {
+      return (true);
+   }
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   @Override
+   public boolean allowWidget(MetaDataInput input, QWidgetMetaDataInterface widget)
+   {
+      return (true);
+   }
+
+}

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

@@ -23,10 +23,12 @@ package com.kingsrook.qqq.backend.core.actions.metadata;
 
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.Comparator;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import com.kingsrook.qqq.backend.core.actions.ActionHelper;
 import com.kingsrook.qqq.backend.core.actions.customizers.QCodeLoader;
 import com.kingsrook.qqq.backend.core.actions.permissions.PermissionCheckResult;
@@ -34,6 +36,7 @@ import com.kingsrook.qqq.backend.core.actions.permissions.PermissionsHelper;
 import com.kingsrook.qqq.backend.core.context.QContext;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
 import com.kingsrook.qqq.backend.core.exceptions.QRuntimeException;
+import com.kingsrook.qqq.backend.core.exceptions.QUserFacingException;
 import com.kingsrook.qqq.backend.core.logging.QLogger;
 import com.kingsrook.qqq.backend.core.model.actions.metadata.MetaDataInput;
 import com.kingsrook.qqq.backend.core.model.actions.metadata.MetaDataOutput;
@@ -65,7 +68,7 @@ public class MetaDataAction
 {
    private static final QLogger LOG = QLogger.getLogger(MetaDataAction.class);
 
-   private static Memoization<QInstance, MetaDataFilterInterface> metaDataFilterMemoization = new Memoization<>();
+   private static Memoization<QInstance, MetaDataActionCustomizerInterface> metaDataActionCustomizerMemoization = new Memoization<>();
 
 
 
@@ -79,7 +82,7 @@ public class MetaDataAction
       MetaDataOutput           metaDataOutput = new MetaDataOutput();
       Map<String, AppTreeNode> treeNodes      = new LinkedHashMap<>();
 
-      MetaDataFilterInterface filter = getMetaDataFilter();
+      MetaDataActionCustomizerInterface customizer = getMetaDataActionCustomizer();
 
       /////////////////////////////////////
       // map tables to frontend metadata //
@@ -90,7 +93,7 @@ public class MetaDataAction
          String         tableName = entry.getKey();
          QTableMetaData table     = entry.getValue();
 
-         if(!filter.allowTable(metaDataInput, table))
+         if(!customizer.allowTable(metaDataInput, table))
          {
             continue;
          }
@@ -119,7 +122,7 @@ public class MetaDataAction
          String           processName = entry.getKey();
          QProcessMetaData process     = entry.getValue();
 
-         if(!filter.allowProcess(metaDataInput, process))
+         if(!customizer.allowProcess(metaDataInput, process))
          {
             continue;
          }
@@ -144,7 +147,7 @@ public class MetaDataAction
          String          reportName = entry.getKey();
          QReportMetaData report     = entry.getValue();
 
-         if(!filter.allowReport(metaDataInput, report))
+         if(!customizer.allowReport(metaDataInput, report))
          {
             continue;
          }
@@ -169,7 +172,7 @@ public class MetaDataAction
          String                   widgetName = entry.getKey();
          QWidgetMetaDataInterface widget     = entry.getValue();
 
-         if(!filter.allowWidget(metaDataInput, widget))
+         if(!customizer.allowWidget(metaDataInput, widget))
          {
             continue;
          }
@@ -206,7 +209,7 @@ public class MetaDataAction
             continue;
          }
 
-         if(!filter.allowApp(metaDataInput, app))
+         if(!customizer.allowApp(metaDataInput, app))
          {
             continue;
          }
@@ -292,11 +295,22 @@ public class MetaDataAction
          metaDataOutput.setBranding(QContext.getQInstance().getBranding());
       }
 
-      metaDataOutput.setEnvironmentValues(QContext.getQInstance().getEnvironmentValues());
+      metaDataOutput.setEnvironmentValues(Objects.requireNonNullElse(QContext.getQInstance().getEnvironmentValues(), Collections.emptyMap()));
 
-      metaDataOutput.setHelpContents(QContext.getQInstance().getHelpContent());
+      metaDataOutput.setHelpContents(Objects.requireNonNullElse(QContext.getQInstance().getHelpContent(), Collections.emptyMap()));
 
-      // todo post-customization - can do whatever w/ the result if you want?
+      try
+      {
+         customizer.postProcess(metaDataOutput);
+      }
+      catch(QUserFacingException e)
+      {
+         LOG.debug("User-facing exception thrown in meta-data customizer post-processing", e);
+      }
+      catch(Exception e)
+      {
+         LOG.warn("Unexpected error thrown in meta-data customizer post-processing", e);
+      }
 
       return metaDataOutput;
    }
@@ -306,26 +320,36 @@ public class MetaDataAction
    /***************************************************************************
     **
     ***************************************************************************/
-   private MetaDataFilterInterface getMetaDataFilter()
+   private MetaDataActionCustomizerInterface getMetaDataActionCustomizer()
    {
-      return metaDataFilterMemoization.getResult(QContext.getQInstance(), i ->
+      return metaDataActionCustomizerMemoization.getResult(QContext.getQInstance(), i ->
       {
-         MetaDataFilterInterface filter                  = null;
-         QCodeReference          metaDataFilterReference = QContext.getQInstance().getMetaDataFilter();
-         if(metaDataFilterReference != null)
+         MetaDataActionCustomizerInterface actionCustomizer                  = null;
+         QCodeReference                    metaDataActionCustomizerReference = QContext.getQInstance().getMetaDataActionCustomizer();
+         if(metaDataActionCustomizerReference != null)
          {
-            filter = QCodeLoader.getAdHoc(MetaDataFilterInterface.class, metaDataFilterReference);
-            LOG.debug("Using new meta-data filter of type: " + filter.getClass().getSimpleName());
+            actionCustomizer = QCodeLoader.getAdHoc(MetaDataActionCustomizerInterface.class, metaDataActionCustomizerReference);
+            LOG.debug("Using new meta-data actionCustomizer of type: " + actionCustomizer.getClass().getSimpleName());
          }
 
-         if(filter == null)
+         if(actionCustomizer == null)
          {
-            filter = new AllowAllMetaDataFilter();
-            LOG.debug("Using new default (allow-all) meta-data filter");
+            QCodeReference metaDataFilterReference = QContext.getQInstance().getMetaDataFilter();
+            if(metaDataFilterReference != null)
+            {
+               actionCustomizer = QCodeLoader.getAdHoc(MetaDataActionCustomizerInterface.class, metaDataFilterReference);
+               LOG.debug("Using new meta-data actionCustomizer (via metaDataFilter reference) of type: " + actionCustomizer.getClass().getSimpleName());
+            }
          }
 
-         return (filter);
-      }).orElseThrow(() -> new QRuntimeException("Error getting metaDataFilter"));
+         if(actionCustomizer == null)
+         {
+            actionCustomizer = new DefaultNoopMetaDataActionCustomizer();
+            LOG.debug("Using new default (allow-all) meta-data actionCustomizer");
+         }
+
+         return (actionCustomizer);
+      }).orElseThrow(() -> new QRuntimeException("Error getting MetaDataActionCustomizer"));
    }
 
 

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

@@ -0,0 +1,78 @@
+/*
+ * 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.metadata;
+
+
+import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.model.actions.metadata.MetaDataInput;
+import com.kingsrook.qqq.backend.core.model.actions.metadata.MetaDataOutput;
+import com.kingsrook.qqq.backend.core.model.metadata.dashboard.QWidgetMetaDataInterface;
+import com.kingsrook.qqq.backend.core.model.metadata.layout.QAppMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.processes.QProcessMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.reporting.QReportMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
+
+
+/*******************************************************************************
+ ** Interface for customizations that can be injected by an application into
+ ** the MetaDataAction - e.g., loading applicable meta-data for a user into a
+ ** frontend.
+ *******************************************************************************/
+public interface MetaDataActionCustomizerInterface
+{
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   boolean allowTable(MetaDataInput input, QTableMetaData table);
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   boolean allowProcess(MetaDataInput input, QProcessMetaData process);
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   boolean allowReport(MetaDataInput input, QReportMetaData report);
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   boolean allowApp(MetaDataInput input, QAppMetaData app);
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   boolean allowWidget(MetaDataInput input, QWidgetMetaDataInterface widget);
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   default void postProcess(MetaDataOutput metaDataOutput) throws QException
+   {
+      /////////////////////
+      // noop by default //
+      /////////////////////
+   }
+
+}

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

@@ -22,43 +22,11 @@
 package com.kingsrook.qqq.backend.core.actions.metadata;
 
 
-import com.kingsrook.qqq.backend.core.model.actions.metadata.MetaDataInput;
-import com.kingsrook.qqq.backend.core.model.metadata.dashboard.QWidgetMetaDataInterface;
-import com.kingsrook.qqq.backend.core.model.metadata.layout.QAppMetaData;
-import com.kingsrook.qqq.backend.core.model.metadata.processes.QProcessMetaData;
-import com.kingsrook.qqq.backend.core.model.metadata.reporting.QReportMetaData;
-import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
-
-
 /*******************************************************************************
  **
  *******************************************************************************/
-public interface MetaDataFilterInterface
+@Deprecated(since = "migrated to metaDataCustomizer")
+public interface MetaDataFilterInterface extends MetaDataActionCustomizerInterface
 {
 
-   /***************************************************************************
-    **
-    ***************************************************************************/
-   boolean allowTable(MetaDataInput input, QTableMetaData table);
-
-   /***************************************************************************
-    **
-    ***************************************************************************/
-   boolean allowProcess(MetaDataInput input, QProcessMetaData process);
-
-   /***************************************************************************
-    **
-    ***************************************************************************/
-   boolean allowReport(MetaDataInput input, QReportMetaData report);
-
-   /***************************************************************************
-    **
-    ***************************************************************************/
-   boolean allowApp(MetaDataInput input, QAppMetaData app);
-
-   /***************************************************************************
-    **
-    ***************************************************************************/
-   boolean allowWidget(MetaDataInput input, QWidgetMetaDataInterface widget);
-
 }

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

@@ -36,6 +36,8 @@ import com.kingsrook.qqq.backend.core.exceptions.QUserFacingException;
 import com.kingsrook.qqq.backend.core.logging.QLogger;
 import com.kingsrook.qqq.backend.core.model.actions.processes.RunBackendStepInput;
 import com.kingsrook.qqq.backend.core.model.actions.processes.RunBackendStepOutput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QCriteriaOperator;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QFilterCriteria;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QQueryFilter;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryOutput;
@@ -46,6 +48,7 @@ import com.kingsrook.qqq.backend.core.model.metadata.processes.QBackendStepMetaD
 import com.kingsrook.qqq.backend.core.model.metadata.processes.QFunctionInputMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.processes.QProcessMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.processes.QStepMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
 import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
 
 
@@ -188,21 +191,40 @@ public class RunBackendStepAction
       {
          if(CollectionUtils.nullSafeIsEmpty(runBackendStepInput.getRecords()))
          {
-            QueryInput queryInput = new QueryInput();
-            queryInput.setTableName(inputMetaData.getRecordListMetaData().getTableName());
+            QTableMetaData table      = QContext.getQInstance().getTable(inputMetaData.getRecordListMetaData().getTableName());
+            QueryInput     queryInput = new QueryInput();
+            queryInput.setTableName(table.getName());
 
-            // todo - handle this being async (e.g., http)
-            // seems like it just needs to throw, breaking this flow, and to send a response to the frontend, directing it to prompt the user for the needed data
-            // then this step can re-run, hopefully with the needed data.
-
-            QProcessCallback callback = runBackendStepInput.getCallback();
-            if(callback == null)
+            //////////////////////////////////////////////////
+            // look for record ids in the input data values //
+            //////////////////////////////////////////////////
+            String recordIds = (String) runBackendStepInput.getValue("recordIds");
+            if(recordIds == null)
             {
-               throw (new QUserFacingException("Missing input records.",
-                  new QException("Function is missing input records, but no callback was present to request fields from a user")));
+               recordIds = (String) runBackendStepInput.getValue("recordId");
             }
 
-            queryInput.setFilter(callback.getQueryFilter());
+            ///////////////////////////////////////////////////////////
+            // if records were found, add as criteria to query input //
+            ///////////////////////////////////////////////////////////
+            if(recordIds != null)
+            {
+               queryInput.setFilter(new QQueryFilter(new QFilterCriteria(table.getPrimaryKeyField(), QCriteriaOperator.IN, recordIds.split(","))));
+            }
+            else
+            {
+               // todo - handle this being async (e.g., http)
+               // seems like it just needs to throw, breaking this flow, and to send a response to the frontend, directing it to prompt the user for the needed data
+               // then this step can re-run, hopefully with the needed data.
+               QProcessCallback callback = runBackendStepInput.getCallback();
+               if(callback == null)
+               {
+                  throw (new QUserFacingException("Missing input records.",
+                     new QException("Function is missing input records, but no callback was present to request fields from a user")));
+               }
+
+               queryInput.setFilter(callback.getQueryFilter());
+            }
 
             //////////////////////////////////////////////////////////////////////////////////////////
             // if process has a max-no of records, set a limit on the process of that number plus 1 //
@@ -210,7 +232,7 @@ public class RunBackendStepAction
             //////////////////////////////////////////////////////////////////////////////////////////
             if(process.getMaxInputRecords() != null)
             {
-               if(callback.getQueryFilter() == null)
+               if(queryInput.getFilter() == null)
                {
                   queryInput.setFilter(new QQueryFilter());
                }

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

@@ -32,6 +32,7 @@ import java.util.Objects;
 import java.util.Optional;
 import java.util.UUID;
 import com.kingsrook.qqq.backend.core.actions.ActionHelper;
+import com.kingsrook.qqq.backend.core.actions.customizers.QCodeLoader;
 import com.kingsrook.qqq.backend.core.actions.dashboard.widgets.NoCodeWidgetRenderer;
 import com.kingsrook.qqq.backend.core.actions.tables.InsertAction;
 import com.kingsrook.qqq.backend.core.actions.tables.QueryAction;
@@ -53,6 +54,7 @@ import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryOutput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.update.UpdateInput;
 import com.kingsrook.qqq.backend.core.model.data.QRecord;
 import com.kingsrook.qqq.backend.core.model.metadata.QBackendMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.code.QCodeReference;
 import com.kingsrook.qqq.backend.core.model.metadata.fields.QFieldMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.processes.NoCodeWidgetFrontendComponentMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.processes.QBackendStepMetaData;
@@ -63,6 +65,7 @@ import com.kingsrook.qqq.backend.core.model.metadata.processes.QStateMachineStep
 import com.kingsrook.qqq.backend.core.model.metadata.processes.QStepMetaData;
 import com.kingsrook.qqq.backend.core.model.session.QSession;
 import com.kingsrook.qqq.backend.core.processes.implementations.basepull.BasepullConfiguration;
+import com.kingsrook.qqq.backend.core.processes.tracing.ProcessTracerInterface;
 import com.kingsrook.qqq.backend.core.state.InMemoryStateProvider;
 import com.kingsrook.qqq.backend.core.state.StateProviderInterface;
 import com.kingsrook.qqq.backend.core.state.StateType;
@@ -71,6 +74,7 @@ import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
 import com.kingsrook.qqq.backend.core.utils.StringUtils;
 import com.kingsrook.qqq.backend.core.utils.ValueUtils;
 import org.apache.commons.lang.BooleanUtils;
+import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
 
 
 /*******************************************************************************
@@ -87,12 +91,16 @@ public class RunProcessAction
    public static final String BASEPULL_TIMESTAMP_FIELD  = "basepullTimestampField";
    public static final String BASEPULL_CONFIGURATION    = "basepullConfiguration";
 
+   public static final String PROCESS_TRACER_CODE_REFERENCE_FIELD = "processTracerCodeReference";
+
    ////////////////////////////////////////////////////////////////////////////////////////////////
    // indicator that the timestamp field should be updated - e.g., the execute step is finished. //
    ////////////////////////////////////////////////////////////////////////////////////////////////
    public static final String BASEPULL_READY_TO_UPDATE_TIMESTAMP_FIELD = "basepullReadyToUpdateTimestamp";
    public static final String BASEPULL_DID_QUERY_USING_TIMESTAMP_FIELD = "basepullDidQueryUsingTimestamp";
 
+   private ProcessTracerInterface processTracer;
+
 
 
    /*******************************************************************************
@@ -119,9 +127,17 @@ public class RunProcessAction
       }
       runProcessOutput.setProcessUUID(runProcessInput.getProcessUUID());
 
+      traceStartOrResume(runProcessInput, process);
+
       UUIDAndTypeStateKey stateKey     = new UUIDAndTypeStateKey(UUID.fromString(runProcessInput.getProcessUUID()), StateType.PROCESS_STATUS);
       ProcessState        processState = primeProcessState(runProcessInput, stateKey, process);
 
+      /////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // these should always be clear when we're starting a run - so make sure they haven't leaked from previous //
+      /////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      processState.clearNextStepName();
+      processState.clearBackStepName();
+
       /////////////////////////////////////////////////////////
       // if process is 'basepull' style, keep track of 'now' //
       /////////////////////////////////////////////////////////
@@ -160,6 +176,7 @@ public class RunProcessAction
          ////////////////////////////////////////////////////////////
          // upon exception (e.g., one thrown by a step), throw it. //
          ////////////////////////////////////////////////////////////
+         traceBreakOrFinish(runProcessInput, runProcessOutput, qe);
          throw (qe);
       }
       catch(Exception e)
@@ -167,6 +184,7 @@ public class RunProcessAction
          ////////////////////////////////////////////////////////////
          // upon exception (e.g., one thrown by a step), throw it. //
          ////////////////////////////////////////////////////////////
+         traceBreakOrFinish(runProcessInput, runProcessOutput, e);
          throw (new QException("Error running process", e));
       }
       finally
@@ -177,6 +195,8 @@ public class RunProcessAction
          runProcessOutput.setProcessState(processState);
       }
 
+      traceBreakOrFinish(runProcessInput, runProcessOutput, null);
+
       return (runProcessOutput);
    }
 
@@ -188,14 +208,35 @@ public class RunProcessAction
    private void runLinearStepLoop(QProcessMetaData process, ProcessState processState, UUIDAndTypeStateKey stateKey, RunProcessInput runProcessInput, RunProcessOutput runProcessOutput) throws Exception
    {
       String lastStepName = runProcessInput.getStartAfterStep();
+      String startAtStep  = runProcessInput.getStartAtStep();
 
       while(true)
       {
          ///////////////////////////////////////////////////////////////////////////////////////////////////////
          // always refresh the step list - as any step that runs can modify it (in the process state).        //
          // this is why we don't do a loop over the step list - as we'd get ConcurrentModificationExceptions. //
+         // deal with if we were told, from the input, to start After a step, or start At a step.             //
          ///////////////////////////////////////////////////////////////////////////////////////////////////////
-         List<QStepMetaData> stepList = getAvailableStepList(processState, process, lastStepName);
+         List<QStepMetaData> stepList;
+         if(startAtStep == null)
+         {
+            stepList = getAvailableStepList(processState, process, lastStepName, false);
+         }
+         else
+         {
+            stepList = getAvailableStepList(processState, process, startAtStep, true);
+
+            ///////////////////////////////////////////////////////////////////////////////////
+            // clear this field - so after we run a step, we'll then loop in last-step mode. //
+            ///////////////////////////////////////////////////////////////////////////////////
+            startAtStep = null;
+
+            ///////////////////////////////////////////////////////////////////////////////////
+            // if we're going to run a backend step now, let it see that this is a step-back //
+            ///////////////////////////////////////////////////////////////////////////////////
+            processState.setIsStepBack(true);
+         }
+
          if(stepList.isEmpty())
          {
             break;
@@ -232,7 +273,18 @@ public class RunProcessAction
             //////////////////////////////////////////////////
             throw (new QException("Unsure how to run a step of type: " + step.getClass().getName()));
          }
+
+         ////////////////////////////////////////////////////////////////////////////////////////
+         // only let this value be set for the original back step - don't let it stick around. //
+         // if a process wants to keep track of this itself, it can, but in a different slot.  //
+         ////////////////////////////////////////////////////////////////////////////////////////
+         processState.setIsStepBack(false);
       }
+
+      ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      // in case we broke from the loop above (e.g., by going directly into a frontend step), once again make sure to lower this flag. //
+      ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      processState.setIsStepBack(false);
    }
 
 
@@ -264,6 +316,12 @@ public class RunProcessAction
             processFrontendStepFieldDefaultValues(processState, step);
             processFrontendComponents(processState, step);
             processState.setNextStepName(step.getName());
+
+            if(StringUtils.hasContent(step.getBackStepName()) && processState.getBackStepName().isEmpty())
+            {
+               processState.setBackStepName(step.getBackStepName());
+            }
+
             return LoopTodo.BREAK;
          }
          case SKIP ->
@@ -317,6 +375,7 @@ public class RunProcessAction
          // else run the given lastStepName //
          /////////////////////////////////////
          processState.clearNextStepName();
+         processState.clearBackStepName();
          step = process.getStep(lastStepName);
          if(step == null)
          {
@@ -398,6 +457,7 @@ public class RunProcessAction
                // its sub-steps, or, to fall out of the loop and end the process.                                  //
                //////////////////////////////////////////////////////////////////////////////////////////////////////
                processState.clearNextStepName();
+               processState.clearBackStepName();
                runStateMachineStep(nextStepName.get(), process, processState, stateKey, runProcessInput, runProcessOutput, stackDepth + 1);
                return;
             }
@@ -584,6 +644,7 @@ public class RunProcessAction
       runBackendStepInput.setCallback(runProcessInput.getCallback());
       runBackendStepInput.setFrontendStepBehavior(runProcessInput.getFrontendStepBehavior());
       runBackendStepInput.setAsyncJobCallback(runProcessInput.getAsyncJobCallback());
+      runBackendStepInput.setProcessTracer(processTracer);
 
       runBackendStepInput.setTableName(process.getTableName());
       if(!StringUtils.hasContent(runBackendStepInput.getTableName()))
@@ -605,9 +666,13 @@ public class RunProcessAction
          runBackendStepInput.setBasepullLastRunTime((Instant) runProcessInput.getValues().get(BASEPULL_LAST_RUNTIME_KEY));
       }
 
+      traceStepStart(runBackendStepInput);
+
       RunBackendStepOutput runBackendStepOutput = new RunBackendStepAction().execute(runBackendStepInput);
       storeState(stateKey, runBackendStepOutput.getProcessState());
 
+      traceStepFinish(runBackendStepInput, runBackendStepOutput);
+
       if(runBackendStepOutput.getException() != null)
       {
          runProcessOutput.setException(runBackendStepOutput.getException());
@@ -621,8 +686,10 @@ public class RunProcessAction
 
    /*******************************************************************************
     ** Get the list of steps which are eligible to run.
+    **
+    ** lastStep will be included in the list, or not, based on includeLastStep.
     *******************************************************************************/
-   private List<QStepMetaData> getAvailableStepList(ProcessState processState, QProcessMetaData process, String lastStep) throws QException
+   static List<QStepMetaData> getAvailableStepList(ProcessState processState, QProcessMetaData process, String lastStep, boolean includeLastStep) throws QException
    {
       if(lastStep == null)
       {
@@ -649,6 +716,10 @@ public class RunProcessAction
             if(stepName.equals(lastStep))
             {
                foundLastStep = true;
+               if(includeLastStep)
+               {
+                  validStepNames.add(stepName);
+               }
             }
          }
          return (stepNamesToSteps(process, validStepNames));
@@ -660,7 +731,7 @@ public class RunProcessAction
    /*******************************************************************************
     **
     *******************************************************************************/
-   private List<QStepMetaData> stepNamesToSteps(QProcessMetaData process, List<String> stepNames) throws QException
+   private static List<QStepMetaData> stepNamesToSteps(QProcessMetaData process, List<String> stepNames) throws QException
    {
       List<QStepMetaData> result = new ArrayList<>();
 
@@ -744,13 +815,14 @@ public class RunProcessAction
       {
          QSession         session         = QContext.getQSession();
          QBackendMetaData backendMetaData = QContext.getQInstance().getBackend(process.getVariantBackend());
-         if(session.getBackendVariants() == null || !session.getBackendVariants().containsKey(backendMetaData.getVariantOptionsTableTypeValue()))
+         String           variantTypeKey  = backendMetaData.getBackendVariantsConfig().getVariantTypeKey();
+         if(session.getBackendVariants() == null || !session.getBackendVariants().containsKey(variantTypeKey))
          {
             LOG.warn("Could not find Backend Variant information for Backend '" + backendMetaData.getName() + "'");
          }
          else
          {
-            basepullKeyValue += "-" + session.getBackendVariants().get(backendMetaData.getVariantOptionsTableTypeValue());
+            basepullKeyValue += "-" + session.getBackendVariants().get(variantTypeKey);
          }
       }
 
@@ -879,4 +951,153 @@ public class RunProcessAction
       runProcessInput.getValues().put(BASEPULL_TIMESTAMP_FIELD, basepullConfiguration.getTimestampField());
       runProcessInput.getValues().put(BASEPULL_CONFIGURATION, basepullConfiguration);
    }
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   private void setupProcessTracer(RunProcessInput runProcessInput, QProcessMetaData process)
+   {
+      try
+      {
+         if(process.getProcessTracerCodeReference() != null)
+         {
+            processTracer = QCodeLoader.getAdHoc(ProcessTracerInterface.class, process.getProcessTracerCodeReference());
+         }
+
+         Serializable processTracerCodeReference = runProcessInput.getValue(PROCESS_TRACER_CODE_REFERENCE_FIELD);
+         if(processTracerCodeReference != null)
+         {
+            if(processTracerCodeReference instanceof QCodeReference codeReference)
+            {
+               processTracer = QCodeLoader.getAdHoc(ProcessTracerInterface.class, codeReference);
+            }
+         }
+      }
+      catch(Exception e)
+      {
+         LOG.warn("Error setting up processTracer", e, logPair("processName", runProcessInput.getProcessName()));
+      }
+   }
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   private void traceStartOrResume(RunProcessInput runProcessInput, QProcessMetaData process)
+   {
+      setupProcessTracer(runProcessInput, process);
+
+      try
+      {
+         if(processTracer != null)
+         {
+            if(StringUtils.hasContent(runProcessInput.getStartAfterStep()) || StringUtils.hasContent(runProcessInput.getStartAtStep()))
+            {
+               processTracer.handleProcessResume(runProcessInput);
+            }
+            else
+            {
+               processTracer.handleProcessStart(runProcessInput);
+            }
+         }
+      }
+      catch(Exception e)
+      {
+         LOG.info("Error in traceStart", e, logPair("processName", runProcessInput.getProcessName()));
+      }
+   }
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   private void traceBreakOrFinish(RunProcessInput runProcessInput, RunProcessOutput runProcessOutput, Exception processException)
+   {
+      try
+      {
+         if(processTracer != null)
+         {
+            ProcessState processState = runProcessOutput.getProcessState();
+            boolean      isBreak      = true;
+
+            /////////////////////////////////////////////////////////////
+            // if there's no next step, that means the process is done //
+            /////////////////////////////////////////////////////////////
+            if(processState.getNextStepName().isEmpty())
+            {
+               isBreak = false;
+            }
+            else
+            {
+               /////////////////////////////////////////////////////////////////
+               // or if the next step is the last index, then we're also done //
+               /////////////////////////////////////////////////////////////////
+               String nextStepName  = processState.getNextStepName().get();
+               int    nextStepIndex = processState.getStepList().indexOf(nextStepName);
+               if(nextStepIndex == processState.getStepList().size() - 1)
+               {
+                  isBreak = false;
+               }
+            }
+
+            if(isBreak)
+            {
+               processTracer.handleProcessBreak(runProcessInput, runProcessOutput, processException);
+            }
+            else
+            {
+               processTracer.handleProcessFinish(runProcessInput, runProcessOutput, processException);
+            }
+         }
+      }
+      catch(Exception e)
+      {
+         LOG.info("Error in traceProcessFinish", e, logPair("processName", runProcessInput.getProcessName()));
+      }
+   }
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   private void traceStepStart(RunBackendStepInput runBackendStepInput)
+   {
+      try
+      {
+         if(processTracer != null)
+         {
+            processTracer.handleStepStart(runBackendStepInput);
+         }
+      }
+      catch(Exception e)
+      {
+         LOG.info("Error in traceStepFinish", e, logPair("processName", runBackendStepInput.getProcessName()), logPair("stepName", runBackendStepInput.getStepName()));
+      }
+   }
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   private void traceStepFinish(RunBackendStepInput runBackendStepInput, RunBackendStepOutput runBackendStepOutput)
+   {
+      try
+      {
+         if(processTracer != null)
+         {
+            processTracer.handleStepFinish(runBackendStepInput, runBackendStepOutput);
+         }
+      }
+      catch(Exception e)
+      {
+         LOG.info("Error in traceStepFinish", e, logPair("processName", runBackendStepInput.getProcessName()), logPair("stepName", runBackendStepInput.getStepName()));
+      }
+   }
+
 }

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

@@ -108,7 +108,7 @@ public class CsvExportStreamer implements ExportStreamerInterface
       }
       catch(Exception e)
       {
-         throw (new QReportingException("Error starting CSV report"));
+         throw (new QReportingException("Error starting CSV report", e));
       }
    }
 

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

@@ -54,6 +54,14 @@ public interface ExportStreamerInterface
       // noop in base class
    }
 
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   default void setExportStyleCustomizer(ExportStyleCustomizerInterface exportStyleCustomizer)
+   {
+      // noop in base class
+   }
+
    /*******************************************************************************
     ** Called once per sheet, before any rows are available.  Meant to write a
     ** header, for example.

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

@@ -0,0 +1,35 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2025.  Kingsrook, LLC
+ * 651 N Broad St Ste 205 # 6917 | Middletown DE 19709 | United States
+ * contact@kingsrook.com
+ * https://github.com/Kingsrook/
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.kingsrook.qqq.backend.core.actions.reporting;
+
+
+/*******************************************************************************
+ ** interface for classes that can be used to customize visual style aspects of
+ ** exports/reports.
+ **
+ ** Anticipates very different sub-interfaces based on the file type being generated,
+ ** and the capabilities of each.  e.g., excel (bolds, fonts, cell merging) vs
+ ** json (different structure of objects).
+ *******************************************************************************/
+public interface ExportStyleCustomizerInterface
+{
+}

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

@@ -71,6 +71,7 @@ import com.kingsrook.qqq.backend.core.model.actions.tables.query.QQueryFilter;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryJoin;
 import com.kingsrook.qqq.backend.core.model.data.QRecord;
+import com.kingsrook.qqq.backend.core.model.metadata.fields.FieldAndJoinTable;
 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.reporting.QReportDataSource;
@@ -162,6 +163,17 @@ public class GenerateReportAction extends AbstractQActionFunction<ReportInput, R
          reportStreamer = reportFormat.newReportStreamer();
       }
 
+      if(reportInput.getExportStyleCustomizer() != null)
+      {
+         ExportStyleCustomizerInterface styleCustomizer = QCodeLoader.getAdHoc(ExportStyleCustomizerInterface.class, reportInput.getExportStyleCustomizer());
+         reportStreamer.setExportStyleCustomizer(styleCustomizer);
+      }
+      else if(report.getExportStyleCustomizer() != null)
+      {
+         ExportStyleCustomizerInterface styleCustomizer = QCodeLoader.getAdHoc(ExportStyleCustomizerInterface.class, report.getExportStyleCustomizer());
+         reportStreamer.setExportStyleCustomizer(styleCustomizer);
+      }
+
       reportStreamer.preRun(reportInput.getReportDestination(), views);
 
       ////////////////////////////////////////////////////////////////////////////////////////////////
@@ -210,7 +222,8 @@ public class GenerateReportAction extends AbstractQActionFunction<ReportInput, R
                /////////////////////////////////////////////////////////////////////////////////////////
                if(dataSourceTableView.getViewCustomizer() != null)
                {
-                  Function<QReportView, QReportView> viewCustomizerFunction = QCodeLoader.getFunction(dataSourceTableView.getViewCustomizer());
+                  @SuppressWarnings("unchecked")
+                  Function<QReportView, QReportView> viewCustomizerFunction = QCodeLoader.getAdHoc(Function.class, dataSourceTableView.getViewCustomizer());
                   if(viewCustomizerFunction instanceof ReportViewCustomizer reportViewCustomizer)
                   {
                      reportViewCustomizer.setReportInput(reportInput);
@@ -567,7 +580,7 @@ public class GenerateReportAction extends AbstractQActionFunction<ReportInput, R
             // all pivotFields that are possible value sources are implicitly translated //
             ///////////////////////////////////////////////////////////////////////////////
             QTableMetaData    mainTable         = QContext.getQInstance().getTable(dataSource.getSourceTable());
-            FieldAndJoinTable fieldAndJoinTable = getFieldAndJoinTable(mainTable, summaryFieldName);
+            FieldAndJoinTable fieldAndJoinTable = FieldAndJoinTable.get(mainTable, summaryFieldName);
             if(fieldAndJoinTable.field().getPossibleValueSourceName() != null)
             {
                fieldsToTranslatePossibleValues.add(summaryFieldName);
@@ -580,32 +593,6 @@ public class GenerateReportAction extends AbstractQActionFunction<ReportInput, R
 
 
 
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   public static FieldAndJoinTable getFieldAndJoinTable(QTableMetaData mainTable, String fieldName) throws QException
-   {
-      if(fieldName.indexOf('.') > -1)
-      {
-         String joinTableName = fieldName.replaceAll("\\..*", "");
-         String joinFieldName = fieldName.replaceAll(".*\\.", "");
-
-         QTableMetaData joinTable = QContext.getQInstance().getTable(joinTableName);
-         if(joinTable == null)
-         {
-            throw (new QException("Unrecognized join table name: " + joinTableName));
-         }
-
-         return new FieldAndJoinTable(joinTable.getField(joinFieldName), joinTable);
-      }
-      else
-      {
-         return new FieldAndJoinTable(mainTable.getField(fieldName), mainTable);
-      }
-   }
-
-
-
    /*******************************************************************************
     **
     *******************************************************************************/
@@ -685,7 +672,7 @@ public class GenerateReportAction extends AbstractQActionFunction<ReportInput, R
          ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          // if any fields are 'showPossibleValueLabel', then move display values for them into the record's values map //
          ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-         for(QReportField column : tableView.getColumns())
+         for(QReportField column : CollectionUtils.nonNullList(tableView.getColumns()))
          {
             if(column.getShowPossibleValueLabel())
             {
@@ -756,7 +743,7 @@ public class GenerateReportAction extends AbstractQActionFunction<ReportInput, R
          SummaryKey key = new SummaryKey();
          for(String summaryFieldName : view.getSummaryFields())
          {
-            FieldAndJoinTable fieldAndJoinTable = getFieldAndJoinTable(table, summaryFieldName);
+            FieldAndJoinTable fieldAndJoinTable = FieldAndJoinTable.get(table, summaryFieldName);
             Serializable      summaryValue      = record.getValue(summaryFieldName);
             if(fieldAndJoinTable.field().getPossibleValueSourceName() != null)
             {
@@ -811,7 +798,7 @@ public class GenerateReportAction extends AbstractQActionFunction<ReportInput, R
             //////////////////////////////////////////////////////
             // todo - memoize this, if we ever need to optimize //
             //////////////////////////////////////////////////////
-            FieldAndJoinTable fieldAndJoinTable = getFieldAndJoinTable(table, fieldName);
+            FieldAndJoinTable fieldAndJoinTable = FieldAndJoinTable.get(table, fieldName);
             field = fieldAndJoinTable.field();
          }
          catch(Exception e)
@@ -956,7 +943,7 @@ public class GenerateReportAction extends AbstractQActionFunction<ReportInput, R
       List<QFieldMetaData> fields = new ArrayList<>();
       for(String summaryFieldName : view.getSummaryFields())
       {
-         FieldAndJoinTable fieldAndJoinTable = getFieldAndJoinTable(table, summaryFieldName);
+         FieldAndJoinTable fieldAndJoinTable = FieldAndJoinTable.get(table, summaryFieldName);
          fields.add(new QFieldMetaData(summaryFieldName, fieldAndJoinTable.field().getType()).withLabel(fieldAndJoinTable.field().getLabel())); // todo do we need the type?  if so need table as input here
       }
       for(QReportField column : view.getColumns())
@@ -1208,27 +1195,4 @@ public class GenerateReportAction extends AbstractQActionFunction<ReportInput, R
    {
    }
 
-
-
-   /*******************************************************************************
-    **
-    *******************************************************************************/
-   public record FieldAndJoinTable(QFieldMetaData field, QTableMetaData joinTable)
-   {
-
-      /*******************************************************************************
-       **
-       *******************************************************************************/
-      public String getLabel(QTableMetaData mainTable)
-      {
-         if(mainTable.getName().equals(joinTable.getName()))
-         {
-            return (field.getLabel());
-         }
-         else
-         {
-            return (joinTable.getLabel() + ": " + field.getLabel());
-         }
-      }
-   }
 }

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

@@ -46,6 +46,7 @@ import java.util.zip.ZipEntry;
 import java.util.zip.ZipInputStream;
 import java.util.zip.ZipOutputStream;
 import com.kingsrook.qqq.backend.core.actions.reporting.ExportStreamerInterface;
+import com.kingsrook.qqq.backend.core.actions.reporting.ExportStyleCustomizerInterface;
 import com.kingsrook.qqq.backend.core.actions.reporting.ReportUtils;
 import com.kingsrook.qqq.backend.core.exceptions.QReportingException;
 import com.kingsrook.qqq.backend.core.instances.QInstanceEnricher;
@@ -77,6 +78,7 @@ import org.apache.poi.xssf.usermodel.XSSFPivotTable;
 import org.apache.poi.xssf.usermodel.XSSFRow;
 import org.apache.poi.xssf.usermodel.XSSFSheet;
 import org.apache.poi.xssf.usermodel.XSSFWorkbook;
+import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
 
 
 /*******************************************************************************
@@ -112,9 +114,10 @@ public class ExcelPoiBasedStreamingExportStreamer implements ExportStreamerInter
    public static final String EXCEL_DATE_FORMAT      = "yyyy-MM-dd";
    public static final String EXCEL_DATE_TIME_FORMAT = "yyyy-MM-dd H:mm:ss";
 
-   private PoiExcelStylerInterface    poiExcelStylerInterface = getStylerInterface();
+   private ExcelPoiBasedStreamingStyleCustomizerInterface styleCustomizerInterface;
+
    private Map<String, String>        excelCellFormats;
-   private Map<String, XSSFCellStyle> styles                  = new HashMap<>();
+   private Map<String, XSSFCellStyle> styles = new HashMap<>();
 
    private int rowNo      = 0;
    private int sheetIndex = 1;
@@ -402,6 +405,7 @@ public class ExcelPoiBasedStreamingExportStreamer implements ExportStreamerInter
       dateTimeStyle.setDataFormat(createHelper.createDataFormat().getFormat(EXCEL_DATE_TIME_FORMAT));
       styles.put("datetime", dateTimeStyle);
 
+      PoiExcelStylerInterface poiExcelStylerInterface = getStylerInterface();
       styles.put("title", poiExcelStylerInterface.createStyleForTitle(workbook, createHelper));
       styles.put("header", poiExcelStylerInterface.createStyleForHeader(workbook, createHelper));
       styles.put("footer", poiExcelStylerInterface.createStyleForFooter(workbook, createHelper));
@@ -413,6 +417,11 @@ public class ExcelPoiBasedStreamingExportStreamer implements ExportStreamerInter
       XSSFCellStyle footerDateTimeStyle = poiExcelStylerInterface.createStyleForFooter(workbook, createHelper);
       footerDateTimeStyle.setDataFormat(createHelper.createDataFormat().getFormat(EXCEL_DATE_TIME_FORMAT));
       styles.put("footer-datetime", footerDateTimeStyle);
+
+      if(styleCustomizerInterface != null)
+      {
+         styleCustomizerInterface.customizeStyles(styles, workbook, createHelper);
+      }
    }
 
 
@@ -458,7 +467,7 @@ public class ExcelPoiBasedStreamingExportStreamer implements ExportStreamerInter
          }
          else
          {
-            sheetWriter.beginSheet();
+            sheetWriter.beginSheet(view, styleCustomizerInterface);
 
             ////////////////////////////////////////////////
             // put the title and header rows in the sheet //
@@ -560,6 +569,16 @@ public class ExcelPoiBasedStreamingExportStreamer implements ExportStreamerInter
 
 
 
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   public static void setStyleForField(QRecord record, String fieldName, String styleName)
+   {
+      record.setDisplayValue(fieldName + ":excelStyle", styleName);
+   }
+
+
+
    /*******************************************************************************
     **
     *******************************************************************************/
@@ -567,12 +586,12 @@ public class ExcelPoiBasedStreamingExportStreamer implements ExportStreamerInter
    {
       sheetWriter.insertRow(rowNo++);
 
-      int styleIndex         = -1;
+      int baseStyleIndex     = -1;
       int dateStyleIndex     = styles.get("date").getIndex();
       int dateTimeStyleIndex = styles.get("datetime").getIndex();
       if(isFooter)
       {
-         styleIndex = styles.get("footer").getIndex();
+         baseStyleIndex = styles.get("footer").getIndex();
          dateStyleIndex = styles.get("footer-date").getIndex();
          dateTimeStyleIndex = styles.get("footer-datetime").getIndex();
       }
@@ -582,6 +601,13 @@ public class ExcelPoiBasedStreamingExportStreamer implements ExportStreamerInter
       {
          Serializable value = qRecord.getValue(field.getName());
 
+         String overrideStyleName = qRecord.getDisplayValue(field.getName() + ":excelStyle");
+         int    styleIndex        = baseStyleIndex;
+         if(overrideStyleName != null)
+         {
+            styleIndex = styles.get(overrideStyleName).getIndex();
+         }
+
          if(value != null)
          {
             if(value instanceof String s)
@@ -706,7 +732,7 @@ public class ExcelPoiBasedStreamingExportStreamer implements ExportStreamerInter
       {
          if(!ReportType.PIVOT.equals(currentView.getType()))
          {
-            sheetWriter.endSheet();
+            sheetWriter.endSheet(currentView, styleCustomizerInterface);
          }
 
          activeSheetWriter.flush();
@@ -815,7 +841,29 @@ public class ExcelPoiBasedStreamingExportStreamer implements ExportStreamerInter
     *******************************************************************************/
    protected PoiExcelStylerInterface getStylerInterface()
    {
+      if(styleCustomizerInterface != null)
+      {
+         return styleCustomizerInterface.getExcelStyler();
+      }
+
       return (new PlainPoiExcelStyler());
    }
 
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   @Override
+   public void setExportStyleCustomizer(ExportStyleCustomizerInterface exportStyleCustomizer)
+   {
+      if(exportStyleCustomizer instanceof ExcelPoiBasedStreamingStyleCustomizerInterface poiExcelStylerInterface)
+      {
+         this.styleCustomizerInterface = poiExcelStylerInterface;
+      }
+      else
+      {
+         LOG.debug("Supplied export style customizer is not an instance of ExcelPoiStyleCustomizerInterface, so will not be used for an excel export", logPair("exportStyleCustomizerClass", exportStyleCustomizer.getClass().getSimpleName()));
+      }
+   }
 }

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

@@ -0,0 +1,81 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2025.  Kingsrook, LLC
+ * 651 N Broad St Ste 205 # 6917 | Middletown DE 19709 | United States
+ * contact@kingsrook.com
+ * https://github.com/Kingsrook/
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.kingsrook.qqq.backend.core.actions.reporting.excel.poi;
+
+
+import java.util.List;
+import java.util.Map;
+import com.kingsrook.qqq.backend.core.actions.reporting.ExportStyleCustomizerInterface;
+import com.kingsrook.qqq.backend.core.model.metadata.reporting.QReportView;
+import org.apache.poi.ss.usermodel.CreationHelper;
+import org.apache.poi.xssf.usermodel.XSSFCellStyle;
+import org.apache.poi.xssf.usermodel.XSSFWorkbook;
+
+
+/*******************************************************************************
+ ** style customization points for Excel files generated via our streaming POI.
+ *******************************************************************************/
+public interface ExcelPoiBasedStreamingStyleCustomizerInterface extends ExportStyleCustomizerInterface
+{
+   /***************************************************************************
+    ** slightly legacy way we did excel styles - but get an instance of object
+    ** that defaults "default" styles (header, footer, etc).
+    ***************************************************************************/
+   default PoiExcelStylerInterface getExcelStyler()
+   {
+      return (new PlainPoiExcelStyler());
+   }
+
+
+   /***************************************************************************
+    ** either change "default" styles put in the styles map, or create new ones
+    ** which can then be applied to row/field values (cells) via:
+    ** ExcelPoiBasedStreamingExportStreamer.setStyleForField(row, fieldName, styleName);
+    ***************************************************************************/
+   default void customizeStyles(Map<String, XSSFCellStyle> styles, XSSFWorkbook workbook, CreationHelper createHelper)
+   {
+      //////////////////
+      // noop default //
+      //////////////////
+   }
+
+
+   /***************************************************************************
+    ** for a given view (sheet), return a list of custom column widths.
+    ** any nulls in the list are ignored (so default width is used).
+    ***************************************************************************/
+   default List<Integer> getColumnWidthsForView(QReportView view)
+   {
+      return (null);
+   }
+
+
+   /***************************************************************************
+    ** for a given view (sheet), return a list of any ranges which should be
+    ** merged, as in "A1:C1" (first three cells in first row).
+    ***************************************************************************/
+   default List<String> getMergedRangesForView(QReportView view)
+   {
+      return (null);
+   }
+
+}

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

@@ -25,7 +25,10 @@ package com.kingsrook.qqq.backend.core.actions.reporting.excel.poi;
 import java.io.IOException;
 import java.io.Writer;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
+import com.kingsrook.qqq.backend.core.model.metadata.reporting.QReportView;
+import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
 import org.apache.poi.ss.util.CellReference;
 
 
@@ -53,13 +56,33 @@ public class StreamedSheetWriter
    /*******************************************************************************
     **
     *******************************************************************************/
-   public void beginSheet() throws IOException
+   public void beginSheet(QReportView view, ExcelPoiBasedStreamingStyleCustomizerInterface styleCustomizerInterface) throws IOException
    {
       writer.write("""
          <?xml version="1.0" encoding="UTF-8"?>
-            <worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
-               <sheetData>""");
+            <worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">""");
 
+      if(styleCustomizerInterface != null && view != null)
+      {
+         List<Integer> columnWidths = styleCustomizerInterface.getColumnWidthsForView(view);
+         if(CollectionUtils.nullSafeHasContents(columnWidths))
+         {
+            writer.write("<cols>");
+            for(int i = 0; i < columnWidths.size(); i++)
+            {
+               Integer width = columnWidths.get(i);
+               if(width != null)
+               {
+                  writer.write("""
+                     <col min="%d" max="%d" width="%d" customWidth="1"/>
+                     """.formatted(i + 1, i + 1, width));
+               }
+            }
+            writer.write("</cols>");
+         }
+      }
+
+      writer.write("<sheetData>");
    }
 
 
@@ -67,11 +90,25 @@ public class StreamedSheetWriter
    /*******************************************************************************
     **
     *******************************************************************************/
-   public void endSheet() throws IOException
+   public void endSheet(QReportView view, ExcelPoiBasedStreamingStyleCustomizerInterface styleCustomizerInterface) throws IOException
    {
-      writer.write("""
-            </sheetData>
-         </worksheet>""");
+      writer.write("</sheetData>");
+
+      if(styleCustomizerInterface != null && view != null)
+      {
+         List<String> mergedRanges = styleCustomizerInterface.getMergedRangesForView(view);
+         if(CollectionUtils.nullSafeHasContents(mergedRanges))
+         {
+            writer.write(String.format("<mergeCells count=\"%d\">", mergedRanges.size()));
+            for(String range : mergedRanges)
+            {
+               writer.write(String.format("<mergeCell ref=\"%s\"/>", range));
+            }
+            writer.write("</mergeCells>");
+         }
+      }
+
+      writer.write("</worksheet>");
    }
 
 
@@ -151,7 +188,7 @@ public class StreamedSheetWriter
             {
                rs.append("&quot;");
             }
-            else if (c < 32 && c != '\t' && c != '\n')
+            else if(c < 32 && c != '\t' && c != '\n')
             {
                rs.append(' ');
             }

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

@@ -53,7 +53,8 @@ public class QJavaExecutor implements QCodeExecutor
       Serializable output;
       try
       {
-         Function<Map<String, Object>, Serializable> function = QCodeLoader.getFunction(codeReference);
+         @SuppressWarnings("unchecked")
+         Function<Map<String, Object>, Serializable> function = QCodeLoader.getAdHoc(Function.class, codeReference);
          output = function.apply(context);
       }
       catch(Exception e)

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

@@ -32,6 +32,7 @@ import com.kingsrook.qqq.backend.core.exceptions.QException;
 import com.kingsrook.qqq.backend.core.logging.QLogger;
 import com.kingsrook.qqq.backend.core.model.actions.tables.count.CountInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.count.CountOutput;
+import com.kingsrook.qqq.backend.core.model.actions.tables.query.QQueryFilter;
 import com.kingsrook.qqq.backend.core.model.metadata.QBackendMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
 import com.kingsrook.qqq.backend.core.model.querystats.QueryStat;
@@ -82,6 +83,22 @@ public class CountAction
 
 
 
+   /*******************************************************************************
+    ** shorthand way to call for the most common use-case, when you just want the
+    ** count to be returned, and you just want to pass in a table name and filter.
+    *******************************************************************************/
+   public static Integer execute(String tableName, QQueryFilter filter) throws QException
+   {
+      CountAction countAction = new CountAction();
+      CountInput  countInput  = new CountInput();
+      countInput.setTableName(tableName);
+      countInput.setFilter(filter);
+      CountOutput countOutput = countAction.execute(countInput);
+      return (countOutput.getCount());
+   }
+
+
+
    /*******************************************************************************
     **
     *******************************************************************************/

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

@@ -82,6 +82,11 @@ public class DeleteAction
    {
       ActionHelper.validateSession(deleteInput);
 
+      if(deleteInput.getTableName() == null)
+      {
+         throw (new QException("Table name was not specified in delete input"));
+      }
+
       QTableMetaData table               = deleteInput.getTable();
       String         primaryKeyFieldName = table.getPrimaryKeyField();
       QFieldMetaData primaryKeyField     = table.getField(primaryKeyFieldName);
@@ -320,7 +325,7 @@ public class DeleteAction
       QTableMetaData table               = deleteInput.getTable();
       List<QRecord>  primaryKeysNotFound = validateRecordsExistAndCanBeAccessed(deleteInput, oldRecordList.get());
 
-      ValidateRecordSecurityLockHelper.validateSecurityFields(table, oldRecordList.get(), ValidateRecordSecurityLockHelper.Action.DELETE);
+      ValidateRecordSecurityLockHelper.validateSecurityFields(table, oldRecordList.get(), ValidateRecordSecurityLockHelper.Action.DELETE, deleteInput.getTransaction());
 
       ///////////////////////////////////////////////////////////////////////////
       // after all validations, run the pre-delete customizer, if there is one //

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

@@ -238,6 +238,11 @@ public class GetAction
     *******************************************************************************/
    public static QRecord execute(String tableName, Serializable primaryKey) throws QException
    {
+      if(primaryKey instanceof QQueryFilter)
+      {
+         LOG.warn("Unexpected use of QQueryFilter instead of primary key in GetAction call");
+      }
+
       GetAction getAction = new GetAction();
       GetInput  getInput  = new GetInput(tableName).withPrimaryKey(primaryKey);
       return getAction.executeForRecord(getInput);

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

@@ -67,6 +67,7 @@ import com.kingsrook.qqq.backend.core.model.statusmessages.QWarningMessage;
 import com.kingsrook.qqq.backend.core.modules.backend.QBackendModuleDispatcher;
 import com.kingsrook.qqq.backend.core.modules.backend.QBackendModuleInterface;
 import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
+import com.kingsrook.qqq.backend.core.utils.StringUtils;
 import com.kingsrook.qqq.backend.core.utils.ValueUtils;
 import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
 
@@ -110,6 +111,12 @@ public class InsertAction extends AbstractQActionFunction<InsertInput, InsertOut
    public InsertOutput execute(InsertInput insertInput) throws QException
    {
       ActionHelper.validateSession(insertInput);
+
+      if(!StringUtils.hasContent(insertInput.getTableName()))
+      {
+         throw (new QException("Table name was not specified in insert input"));
+      }
+
       QTableMetaData table = insertInput.getTable();
 
       if(table == null)
@@ -122,7 +129,7 @@ public class InsertAction extends AbstractQActionFunction<InsertInput, InsertOut
       /////////////////////////////
       // run standard validators //
       /////////////////////////////
-      performValidations(insertInput, false);
+      performValidations(insertInput, false, false);
 
       //////////////////////////////////////////////////////
       // use the backend module to actually do the insert //
@@ -225,7 +232,7 @@ public class InsertAction extends AbstractQActionFunction<InsertInput, InsertOut
    /*******************************************************************************
     **
     *******************************************************************************/
-   public void performValidations(InsertInput insertInput, boolean isPreview) throws QException
+   public void performValidations(InsertInput insertInput, boolean isPreview, boolean didAlreadyRunCustomizer) throws QException
    {
       if(CollectionUtils.nullSafeIsEmpty(insertInput.getRecords()))
       {
@@ -237,12 +244,10 @@ public class InsertAction extends AbstractQActionFunction<InsertInput, InsertOut
       ///////////////////////////////////////////////////////////////////
       // load the pre-insert customizer and set it up, if there is one //
       // then we'll run it based on its WhenToRun value                //
+      // note - if we already ran it, then don't re-run it!            //
       ///////////////////////////////////////////////////////////////////
-      Optional<TableCustomizerInterface> preInsertCustomizer = QCodeLoader.getTableCustomizer(table, TableCustomizers.PRE_INSERT_RECORD.getRole());
-      if(preInsertCustomizer.isPresent())
-      {
-         runPreInsertCustomizerIfItIsTime(insertInput, isPreview, preInsertCustomizer, AbstractPreInsertCustomizer.WhenToRun.BEFORE_ALL_VALIDATIONS);
-      }
+      Optional<TableCustomizerInterface> preInsertCustomizer = didAlreadyRunCustomizer ? Optional.empty() : QCodeLoader.getTableCustomizer(table, TableCustomizers.PRE_INSERT_RECORD.getRole());
+      runPreInsertCustomizerIfItIsTime(insertInput, isPreview, preInsertCustomizer, AbstractPreInsertCustomizer.WhenToRun.BEFORE_ALL_VALIDATIONS);
 
       setDefaultValuesInRecords(table, insertInput.getRecords());
 
@@ -258,7 +263,7 @@ public class InsertAction extends AbstractQActionFunction<InsertInput, InsertOut
       }
 
       runPreInsertCustomizerIfItIsTime(insertInput, isPreview, preInsertCustomizer, AbstractPreInsertCustomizer.WhenToRun.BEFORE_SECURITY_CHECKS);
-      ValidateRecordSecurityLockHelper.validateSecurityFields(insertInput.getTable(), insertInput.getRecords(), ValidateRecordSecurityLockHelper.Action.INSERT);
+      ValidateRecordSecurityLockHelper.validateSecurityFields(insertInput.getTable(), insertInput.getRecords(), ValidateRecordSecurityLockHelper.Action.INSERT, insertInput.getTransaction());
 
       runPreInsertCustomizerIfItIsTime(insertInput, isPreview, preInsertCustomizer, AbstractPreInsertCustomizer.WhenToRun.AFTER_ALL_VALIDATIONS);
    }

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

@@ -47,7 +47,8 @@ public class StorageAction
 {
 
    /*******************************************************************************
-    **
+    ** create an output stream in the storage backend - that can be written to,
+    ** for the purpose of inserting or writing a file into storage.
     *******************************************************************************/
    public OutputStream createOutputStream(StorageInput storageInput) throws QException
    {
@@ -59,7 +60,8 @@ public class StorageAction
 
 
    /*******************************************************************************
-    **
+    ** create an input stream in the storage backend - that can be read from,
+    ** for the purpose of getting or reading a file from storage.
     *******************************************************************************/
    public InputStream getInputStream(StorageInput storageInput) throws QException
    {

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

@@ -74,6 +74,7 @@ import com.kingsrook.qqq.backend.core.model.statusmessages.QWarningMessage;
 import com.kingsrook.qqq.backend.core.modules.backend.QBackendModuleDispatcher;
 import com.kingsrook.qqq.backend.core.modules.backend.QBackendModuleInterface;
 import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
+import com.kingsrook.qqq.backend.core.utils.StringUtils;
 import com.kingsrook.qqq.backend.core.utils.ValueUtils;
 import org.apache.commons.lang.BooleanUtils;
 import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
@@ -118,6 +119,11 @@ public class UpdateAction
    {
       ActionHelper.validateSession(updateInput);
 
+      if(!StringUtils.hasContent(updateInput.getTableName()))
+      {
+         throw (new QException("Table name was not specified in update input"));
+      }
+
       QTableMetaData table = updateInput.getTable();
 
       //////////////////////////////////////////////////////
@@ -261,7 +267,7 @@ public class UpdateAction
       }
       else
       {
-         ValidateRecordSecurityLockHelper.validateSecurityFields(table, updateInput.getRecords(), ValidateRecordSecurityLockHelper.Action.UPDATE);
+         ValidateRecordSecurityLockHelper.validateSecurityFields(table, updateInput.getRecords(), ValidateRecordSecurityLockHelper.Action.UPDATE, updateInput.getTransaction());
       }
 
       if(updateInput.getInputSource().shouldValidateRequiredFields())
@@ -374,7 +380,7 @@ public class UpdateAction
             }
          }
 
-         ValidateRecordSecurityLockHelper.validateSecurityFields(table, updateInput.getRecords(), ValidateRecordSecurityLockHelper.Action.UPDATE);
+         ValidateRecordSecurityLockHelper.validateSecurityFields(table, updateInput.getRecords(), ValidateRecordSecurityLockHelper.Action.UPDATE, updateInput.getTransaction());
 
          for(QRecord record : page)
          {

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

@@ -31,16 +31,12 @@ import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
 import java.util.function.Supplier;
-import com.kingsrook.qqq.backend.core.actions.tables.GetAction;
 import com.kingsrook.qqq.backend.core.actions.tables.InsertAction;
 import com.kingsrook.qqq.backend.core.context.QContext;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
 import com.kingsrook.qqq.backend.core.instances.QMetaDataVariableInterpreter;
 import com.kingsrook.qqq.backend.core.logging.QLogger;
-import com.kingsrook.qqq.backend.core.model.actions.tables.get.GetInput;
-import com.kingsrook.qqq.backend.core.model.actions.tables.get.GetOutput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.insert.InsertInput;
-import com.kingsrook.qqq.backend.core.model.actions.tables.insert.InsertOutput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QFilterCriteria;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QFilterOrderBy;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QQueryFilter;
@@ -54,12 +50,10 @@ import com.kingsrook.qqq.backend.core.model.querystats.QueryStatCriteriaField;
 import com.kingsrook.qqq.backend.core.model.querystats.QueryStatJoinTable;
 import com.kingsrook.qqq.backend.core.model.querystats.QueryStatOrderByField;
 import com.kingsrook.qqq.backend.core.model.session.QSession;
-import com.kingsrook.qqq.backend.core.model.tables.QQQTable;
-import com.kingsrook.qqq.backend.core.model.tables.QQQTablesMetaDataProvider;
+import com.kingsrook.qqq.backend.core.model.tables.QQQTableTableManager;
 import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
 import com.kingsrook.qqq.backend.core.utils.PrefixedDefaultThreadFactory;
 import com.kingsrook.qqq.backend.core.utils.StringUtils;
-import com.kingsrook.qqq.backend.core.utils.collections.MapBuilder;
 import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
 
 
@@ -371,7 +365,7 @@ public class QueryStatManager
                   //////////////////////
                   // set the table id //
                   //////////////////////
-                  Integer qqqTableId = getQQQTableId(queryStat.getTableName());
+                  Integer qqqTableId = QQQTableTableManager.getQQQTableId(getInstance().qInstance, queryStat.getTableName());
                   queryStat.setQqqTableId(qqqTableId);
 
                   //////////////////////////////
@@ -382,7 +376,7 @@ public class QueryStatManager
                      List<QueryStatJoinTable> queryStatJoinTableList = new ArrayList<>();
                      for(String joinTableName : queryStat.getJoinTableNames())
                      {
-                        queryStatJoinTableList.add(new QueryStatJoinTable().withQqqTableId(getQQQTableId(joinTableName)));
+                        queryStatJoinTableList.add(new QueryStatJoinTable().withQqqTableId(QQQTableTableManager.getQQQTableId(getInstance().qInstance, joinTableName)));
                      }
                      queryStat.setQueryStatJoinTableList(queryStatJoinTableList);
                   }
@@ -460,7 +454,7 @@ public class QueryStatManager
                String[] parts = fieldName.split("\\.");
                if(parts.length > 1)
                {
-                  queryStatCriteriaField.setQqqTableId(getQQQTableId(parts[0]));
+                  queryStatCriteriaField.setQqqTableId(QQQTableTableManager.getQQQTableId(getInstance().qInstance, parts[0]));
                   queryStatCriteriaField.setName(parts[1]);
                }
             }
@@ -498,7 +492,7 @@ public class QueryStatManager
                   String[] parts = fieldName.split("\\.");
                   if(parts.length > 1)
                   {
-                     queryStatOrderByField.setQqqTableId(getQQQTableId(parts[0]));
+                     queryStatOrderByField.setQqqTableId(QQQTableTableManager.getQQQTableId(getInstance().qInstance, parts[0]));
                      queryStatOrderByField.setName(parts[1]);
                   }
                }
@@ -512,44 +506,6 @@ public class QueryStatManager
             }
          }
       }
-
-
-
-      /*******************************************************************************
-       **
-       *******************************************************************************/
-      private static Integer getQQQTableId(String tableName) throws QException
-      {
-         /////////////////////////////
-         // look in the cache table //
-         /////////////////////////////
-         GetInput getInput = new GetInput();
-         getInput.setTableName(QQQTablesMetaDataProvider.QQQ_TABLE_CACHE_TABLE_NAME);
-         getInput.setUniqueKey(MapBuilder.of("name", tableName));
-         GetOutput getOutput = new GetAction().execute(getInput);
-
-         ////////////////////////
-         // upon cache miss... //
-         ////////////////////////
-         if(getOutput.getRecord() == null)
-         {
-            ///////////////////////////////////////////////////////
-            // insert the record (into the table, not the cache) //
-            ///////////////////////////////////////////////////////
-            QTableMetaData tableMetaData = getInstance().qInstance.getTable(tableName);
-            InsertInput    insertInput   = new InsertInput();
-            insertInput.setTableName(QQQTable.TABLE_NAME);
-            insertInput.setRecords(List.of(new QRecord().withValue("name", tableName).withValue("label", tableMetaData.getLabel())));
-            InsertOutput insertOutput = new InsertAction().execute(insertInput);
-
-            ///////////////////////////////////
-            // repeat the get from the cache //
-            ///////////////////////////////////
-            getOutput = new GetAction().execute(getInput);
-         }
-
-         return getOutput.getRecord().getValueInteger("id");
-      }
    }
 
 

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

@@ -50,6 +50,7 @@ import com.kingsrook.qqq.backend.core.utils.ValueUtils;
  *******************************************************************************/
 public class UniqueKeyHelper
 {
+   private static Integer pageSize = 1000;
 
    /*******************************************************************************
     **
@@ -60,62 +61,71 @@ public class UniqueKeyHelper
       Map<List<Serializable>, Serializable> existingRecords = new HashMap<>();
       if(ukFieldNames != null)
       {
-         QueryInput queryInput = new QueryInput();
-         queryInput.setTableName(table.getName());
-         queryInput.setTransaction(transaction);
+         for(List<QRecord> page : CollectionUtils.getPages(recordList, pageSize))
+         {
+            QueryInput queryInput = new QueryInput();
+            queryInput.setTableName(table.getName());
+            queryInput.setTransaction(transaction);
 
-         QQueryFilter filter = new QQueryFilter();
-         if(ukFieldNames.size() == 1)
-         {
-            List<Serializable> values = recordList.stream()
-               .filter(r -> CollectionUtils.nullSafeIsEmpty(r.getErrors()))
-               .map(r -> r.getValue(ukFieldNames.get(0)))
-               .collect(Collectors.toList());
-            filter.addCriteria(new QFilterCriteria(ukFieldNames.get(0), QCriteriaOperator.IN, values));
-         }
-         else
-         {
-            filter.setBooleanOperator(QQueryFilter.BooleanOperator.OR);
-            for(QRecord record : recordList)
+            QQueryFilter filter = new QQueryFilter();
+            if(ukFieldNames.size() == 1)
             {
-               if(CollectionUtils.nullSafeHasContents(record.getErrors()))
+               List<Serializable> values = page.stream()
+                  .filter(r -> CollectionUtils.nullSafeIsEmpty(r.getErrors()))
+                  .map(r -> r.getValue(ukFieldNames.get(0)))
+                  .collect(Collectors.toList());
+
+               if(values.isEmpty())
                {
                   continue;
                }
 
-               QQueryFilter subFilter = new QQueryFilter();
-               filter.addSubFilter(subFilter);
-               for(String fieldName : ukFieldNames)
+               filter.addCriteria(new QFilterCriteria(ukFieldNames.get(0), QCriteriaOperator.IN, values));
+            }
+            else
+            {
+               filter.setBooleanOperator(QQueryFilter.BooleanOperator.OR);
+               for(QRecord record : page)
                {
-                  Serializable value = record.getValue(fieldName);
-                  if(value == null)
+                  if(CollectionUtils.nullSafeHasContents(record.getErrors()))
                   {
-                     subFilter.addCriteria(new QFilterCriteria(fieldName, QCriteriaOperator.IS_BLANK));
+                     continue;
                   }
-                  else
+
+                  QQueryFilter subFilter = new QQueryFilter();
+                  filter.addSubFilter(subFilter);
+                  for(String fieldName : ukFieldNames)
                   {
-                     subFilter.addCriteria(new QFilterCriteria(fieldName, QCriteriaOperator.EQUALS, value));
+                     Serializable value = record.getValue(fieldName);
+                     if(value == null)
+                     {
+                        subFilter.addCriteria(new QFilterCriteria(fieldName, QCriteriaOperator.IS_BLANK));
+                     }
+                     else
+                     {
+                        subFilter.addCriteria(new QFilterCriteria(fieldName, QCriteriaOperator.EQUALS, value));
+                     }
                   }
                }
+
+               if(CollectionUtils.nullSafeIsEmpty(filter.getSubFilters()))
+               {
+                  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                  // if we didn't build any sub-filters (because all records have errors in them), don't run a query w/ no clauses - continue to next page //
+                  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                  continue;
+               }
             }
 
-            if(CollectionUtils.nullSafeIsEmpty(filter.getSubFilters()))
+            queryInput.setFilter(filter);
+            QueryOutput queryOutput = new QueryAction().execute(queryInput);
+            for(QRecord record : queryOutput.getRecords())
             {
-               ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-               // if we didn't build any sub-filters (because all records have errors in them), don't run a query w/ no clauses - rather - return early. //
-               ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-               return (existingRecords);
-            }
-         }
-
-         queryInput.setFilter(filter);
-         QueryOutput queryOutput = new QueryAction().execute(queryInput);
-         for(QRecord record : queryOutput.getRecords())
-         {
-            Optional<List<Serializable>> keyValues = getKeyValues(table, uniqueKey, record, allowNullKeyValuesToEqual);
-            if(keyValues.isPresent())
-            {
-               existingRecords.put(keyValues.get(), record.getValue(table.getPrimaryKeyField()));
+               Optional<List<Serializable>> keyValues = getKeyValues(table, uniqueKey, record, allowNullKeyValuesToEqual);
+               if(keyValues.isPresent())
+               {
+                  existingRecords.put(keyValues.get(), record.getValue(table.getPrimaryKeyField()));
+               }
             }
          }
       }
@@ -200,4 +210,26 @@ public class UniqueKeyHelper
       }
    }
 
+
+
+   /*******************************************************************************
+    ** Getter for pageSize
+    **
+    *******************************************************************************/
+   public static Integer getPageSize()
+   {
+      return pageSize;
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for pageSize
+    **
+    *******************************************************************************/
+   public static void setPageSize(Integer pageSize)
+   {
+      UniqueKeyHelper.pageSize = pageSize;
+   }
+
 }

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

@@ -28,6 +28,7 @@ import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import com.kingsrook.qqq.backend.core.actions.QBackendTransaction;
 import com.kingsrook.qqq.backend.core.actions.tables.QueryAction;
 import com.kingsrook.qqq.backend.core.context.QContext;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
@@ -83,7 +84,7 @@ public class ValidateRecordSecurityLockHelper
    /*******************************************************************************
     **
     *******************************************************************************/
-   public static void validateSecurityFields(QTableMetaData table, List<QRecord> records, Action action) throws QException
+   public static void validateSecurityFields(QTableMetaData table, List<QRecord> records, Action action, QBackendTransaction transaction) throws QException
    {
       MultiRecordSecurityLock locksToCheck = getRecordSecurityLocks(table, action);
       if(locksToCheck == null || CollectionUtils.nullSafeIsEmpty(locksToCheck.getLocks()))
@@ -101,7 +102,7 @@ public class ValidateRecordSecurityLockHelper
       // actually check lock values //
       ////////////////////////////////
       Map<Serializable, RecordWithErrors> errorRecords = new HashMap<>();
-      evaluateRecordLocks(table, records, action, locksToCheck, errorRecords, new ArrayList<>(), madeUpPrimaryKeys);
+      evaluateRecordLocks(table, records, action, locksToCheck, errorRecords, new ArrayList<>(), madeUpPrimaryKeys, transaction);
 
       /////////////////////////////////
       // propagate errors to records //
@@ -141,7 +142,7 @@ public class ValidateRecordSecurityLockHelper
     ** BUT - WRITE locks - in their case, we read the record no matter what, and in
     ** here we need to verify we have a key that allows us to WRITE the record.
     *******************************************************************************/
-   private static void evaluateRecordLocks(QTableMetaData table, List<QRecord> records, Action action, RecordSecurityLock recordSecurityLock, Map<Serializable, RecordWithErrors> errorRecords, List<Integer> treePosition, Map<Serializable, QRecord> madeUpPrimaryKeys) throws QException
+   private static void evaluateRecordLocks(QTableMetaData table, List<QRecord> records, Action action, RecordSecurityLock recordSecurityLock, Map<Serializable, RecordWithErrors> errorRecords, List<Integer> treePosition, Map<Serializable, QRecord> madeUpPrimaryKeys, QBackendTransaction transaction) throws QException
    {
       if(recordSecurityLock instanceof MultiRecordSecurityLock multiRecordSecurityLock)
       {
@@ -152,7 +153,7 @@ public class ValidateRecordSecurityLockHelper
          for(RecordSecurityLock childLock : CollectionUtils.nonNullList(multiRecordSecurityLock.getLocks()))
          {
             treePosition.add(i);
-            evaluateRecordLocks(table, records, action, childLock, errorRecords, treePosition, madeUpPrimaryKeys);
+            evaluateRecordLocks(table, records, action, childLock, errorRecords, treePosition, madeUpPrimaryKeys, transaction);
             treePosition.remove(treePosition.size() - 1);
             i++;
          }
@@ -225,6 +226,7 @@ public class ValidateRecordSecurityLockHelper
             // query will be like (fkey1=? and fkey2=?) OR (fkey1=? and fkey2=?) OR (fkey1=? and fkey2=?) //
             ////////////////////////////////////////////////////////////////////////////////////////////////
             QueryInput queryInput = new QueryInput();
+            queryInput.setTransaction(transaction);
             queryInput.setTableName(leftMostJoin.getLeftTable());
             QQueryFilter filter = new QQueryFilter().withBooleanOperator(QQueryFilter.BooleanOperator.OR);
             queryInput.setFilter(filter);

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

@@ -26,22 +26,32 @@ import java.nio.file.Path;
 import java.util.Map;
 import com.kingsrook.qqq.backend.core.actions.AbstractQActionFunction;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
 import com.kingsrook.qqq.backend.core.model.actions.templates.ConvertHtmlToPdfInput;
 import com.kingsrook.qqq.backend.core.model.actions.templates.ConvertHtmlToPdfOutput;
 import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
+import com.openhtmltopdf.css.constants.IdentValue;
+import com.openhtmltopdf.pdfboxout.PdfBoxFontResolver;
+import com.openhtmltopdf.pdfboxout.PdfBoxRenderer;
+import com.openhtmltopdf.pdfboxout.PdfRendererBuilder;
 import org.jsoup.Jsoup;
+import org.jsoup.helper.W3CDom;
 import org.jsoup.nodes.Document;
-import org.xhtmlrenderer.layout.SharedContext;
-import org.xhtmlrenderer.pdf.ITextRenderer;
 
 
 /*******************************************************************************
  ** Action to convert a string of HTML to a PDF!
  **
  ** Much credit to https://www.baeldung.com/java-html-to-pdf
- *******************************************************************************/
+ **
+ ** Updated in March 2025 to go from flying-saucer-pdf-openpdf lib to openhtmltopdf,
+ ** mostly to get support for max-height on images...
+ ********************************************************************************/
 public class ConvertHtmlToPdfAction extends AbstractQActionFunction<ConvertHtmlToPdfInput, ConvertHtmlToPdfOutput>
 {
+   private static final QLogger LOG = QLogger.getLogger(ConvertHtmlToPdfAction.class);
+
+
 
    /*******************************************************************************
     **
@@ -58,35 +68,37 @@ public class ConvertHtmlToPdfAction extends AbstractQActionFunction<ConvertHtmlT
          //////////////////////////////////////////////////////////////////
          Document document = Jsoup.parse(input.getHtml());
          document.outputSettings().syntax(Document.OutputSettings.Syntax.xml);
+         org.w3c.dom.Document w3cDoc = new W3CDom().fromJsoup(document);
 
          //////////////////////////////
          // convert the XHTML to PDF //
          //////////////////////////////
-         ITextRenderer renderer      = new ITextRenderer();
-         SharedContext sharedContext = renderer.getSharedContext();
-         sharedContext.setPrint(true);
-         sharedContext.setInteractive(false);
+         PdfRendererBuilder builder = new PdfRendererBuilder();
+         builder.toStream(input.getOutputStream());
+         builder.useFastMode();
+         builder.withW3cDocument(w3cDoc, input.getBasePath() == null ? "./" : input.getBasePath().toUri().toString());
 
-         if(input.getBasePath() != null)
+         try(PdfBoxRenderer pdfBoxRenderer = builder.buildPdfRenderer())
          {
-            String baseUrl = input.getBasePath().toUri().toURL().toString();
-            renderer.setDocumentFromString(document.html(), baseUrl);
-         }
-         else
-         {
-            renderer.setDocumentFromString(document.html());
-         }
+            pdfBoxRenderer.layout();
+            pdfBoxRenderer.getSharedContext().setPrint(true);
+            pdfBoxRenderer.getSharedContext().setInteractive(false);
 
-         //////////////////////////////////////////////////
-         // register any custom fonts the input supplied //
-         //////////////////////////////////////////////////
-         for(Map.Entry<String, Path> entry : CollectionUtils.nonNullMap(input.getCustomFonts()).entrySet())
-         {
-            renderer.getFontResolver().addFont(entry.getValue().toAbsolutePath().toString(), entry.getKey(), "UTF-8", true, null);
-         }
+            for(Map.Entry<String, Path> entry : CollectionUtils.nonNullMap(input.getCustomFonts()).entrySet())
+            {
+               LOG.warn("Note:  Custom fonts appear to not be working in this class at this time...");
+               pdfBoxRenderer.getFontResolver().addFont(
+                  entry.getValue().toAbsolutePath().toFile(), // Path to the TrueType font file
+                  entry.getKey(),                             // Font family name to use in CSS
+                  400,                                        // Font weight (e.g., 400 for normal, 700 for bold)
+                  IdentValue.NORMAL,                          // Font style (e.g., NORMAL, ITALIC)
+                  true,                                       // Whether to subset the font
+                  PdfBoxFontResolver.FontGroup.MAIN           // ??
+               );
+            }
 
-         renderer.layout();
-         renderer.createPDF(input.getOutputStream());
+            pdfBoxRenderer.createPDF();
+         }
 
          return (output);
       }

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

@@ -104,10 +104,21 @@ public class RenderTemplateAction extends AbstractQActionFunction<RenderTemplate
 
 
 
+   /*******************************************************************************
+    ** Static wrapper to render a Velocity template.
+    *******************************************************************************/
+   @Deprecated(since = "Call the version that doesn't take an ActionInput")
+   public static String renderVelocity(AbstractActionInput parentActionInput, Map<String, Object> context, String code) throws QException
+   {
+      return (renderVelocity(context, code));
+   }
+
+
+
    /*******************************************************************************
     ** Most convenient static wrapper to render a Velocity template.
     *******************************************************************************/
-   public static String renderVelocity(AbstractActionInput parentActionInput, Map<String, Object> context, String code) throws QException
+   public static String renderVelocity(Map<String, Object> context, String code) throws QException
    {
       return (render(TemplateType.VELOCITY, context, code));
    }

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

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

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

@@ -24,6 +24,7 @@ package com.kingsrook.qqq.backend.core.actions.values;
 
 import java.io.Serializable;
 import java.util.ArrayList;
+import java.util.Comparator;
 import java.util.List;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
 import com.kingsrook.qqq.backend.core.model.actions.values.SearchPossibleValueSourceInput;
@@ -74,6 +75,31 @@ public interface QCustomPossibleValueProvider<T extends Serializable>
    }
 
 
+   /***************************************************************************
+    ** meant to be protected (but interface...) - for a custom PVS implementation
+    ** to complete its search (e.g., after it generates the list of PVS objects,
+    ** let this method do the filtering).
+    ***************************************************************************/
+   default List<QPossibleValue<T>> completeCustomPVSSearch(SearchPossibleValueSourceInput input, List<QPossibleValue<T>> possibleValues)
+   {
+      SearchPossibleValueSourceAction.PreparedSearchPossibleValueSourceInput preparedInput = SearchPossibleValueSourceAction.prepareSearchPossibleValueSourceInput(input);
+
+      List<QPossibleValue<T>> rs = new ArrayList<>();
+
+      for(QPossibleValue<T> possibleValue : possibleValues)
+      {
+         if(possibleValue != null && SearchPossibleValueSourceAction.doesPossibleValueMatchSearchInput(possibleValue, preparedInput))
+         {
+            rs.add(possibleValue);
+         }
+      }
+
+      rs.sort(Comparator.nullsLast(Comparator.comparing((QPossibleValue<T> pv) -> pv.getLabel())));
+
+      return (rs);
+   }
+
+
    /*******************************************************************************
     **
     *******************************************************************************/

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

@@ -341,7 +341,7 @@ public class QPossibleValueTranslator
 
       try
       {
-         QCustomPossibleValueProvider customPossibleValueProvider = QCodeLoader.getCustomPossibleValueProvider(possibleValueSource);
+         QCustomPossibleValueProvider<?> customPossibleValueProvider = QCodeLoader.getAdHoc(QCustomPossibleValueProvider.class, possibleValueSource.getCustomCodeReference());
          return (formatPossibleValue(possibleValueSource, customPossibleValueProvider.getPossibleValue(value)));
       }
       catch(Exception e)

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

@@ -28,6 +28,7 @@ import java.time.LocalDateTime;
 import java.time.LocalTime;
 import java.time.ZonedDateTime;
 import java.time.format.DateTimeFormatter;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -44,6 +45,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.StringUtils;
 import com.kingsrook.qqq.backend.core.utils.ValueUtils;
+import org.apache.commons.lang3.BooleanUtils;
 import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
 
 
@@ -484,6 +486,8 @@ public class QValueFormatter
             String fileNameFormat   = ValueUtils.getValueAsString(adornmentValues.get(AdornmentType.FileDownloadValues.FILE_NAME_FORMAT));
             String defaultExtension = ValueUtils.getValueAsString(adornmentValues.get(AdornmentType.FileDownloadValues.DEFAULT_EXTENSION));
 
+            Boolean downloadUrlDynamic = ValueUtils.getValueAsBoolean(adornmentValues.get(AdornmentType.FileDownloadValues.DOWNLOAD_URL_DYNAMIC));
+
             for(QRecord record : records)
             {
                if(!doesFieldHaveValue(field, record))
@@ -491,6 +495,11 @@ public class QValueFormatter
                   continue;
                }
 
+               if(BooleanUtils.isTrue(downloadUrlDynamic))
+               {
+                  continue;
+               }
+
                Serializable primaryKey = record.getValue(table.getPrimaryKeyField());
                String       fileName   = null;
 
@@ -508,7 +517,7 @@ public class QValueFormatter
                   {
                      @SuppressWarnings("unchecked") // instance validation should make this safe!
                      List<String> fileNameFormatFields = (List<String>) adornmentValues.get(AdornmentType.FileDownloadValues.FILE_NAME_FORMAT_FIELDS);
-                     List<String> values = fileNameFormatFields.stream().map(f -> ValueUtils.getValueAsString(record.getValue(f))).toList();
+                     List<String> values = CollectionUtils.nullSafeHasContents(fileNameFormatFields) ? fileNameFormatFields.stream().map(f -> ValueUtils.getValueAsString(record.getValue(f))).toList() : Collections.emptyList();
                      fileName = QValueFormatter.formatStringWithValues(fileNameFormat, values);
                   }
                }
@@ -529,12 +538,18 @@ public class QValueFormatter
                   }
                }
 
-               /////////////////////////////////////////////
-               // if field type is blob, update its value //
-               /////////////////////////////////////////////
-               if(QFieldType.BLOB.equals(field.getType()))
+               ////////////////////////////////////////////////////////////////////////////////////////////////
+               // if field type is blob OR if there's a supplemental process or code-ref that needs to run - //
+               // then update its value to be a callback-url that'll give access to the bytes to download.   //
+               // implied here is that a String value (w/o supplemental code/proc) has its value stay as a   //
+               // URL, which is where the file is directly downloaded from.  And in the case of a String     //
+               // with code-to-run, then the code should run, followed by a redirect to the value URL.       //
+               ////////////////////////////////////////////////////////////////////////////////////////////////
+               if(QFieldType.BLOB.equals(field.getType())
+                  || adornmentValues.containsKey(AdornmentType.FileDownloadValues.SUPPLEMENTAL_CODE_REFERENCE)
+                  || adornmentValues.containsKey(AdornmentType.FileDownloadValues.SUPPLEMENTAL_PROCESS_NAME))
                {
-                  record.setValue(field.getName(), "/data/" + table.getName() + "/" + primaryKey + "/" + field.getName() + "/" + fileName);
+                  record.setValue(field.getName(), AdornmentType.FileDownloadValues.makeFieldDownloadUrl(table.getName(), primaryKey, field.getName(), fileName));
                }
                record.setDisplayValue(field.getName(), fileName);
             }

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

@@ -26,8 +26,13 @@ import java.io.Serializable;
 import java.time.Instant;
 import java.time.LocalDate;
 import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Collectors;
 import com.kingsrook.qqq.backend.core.actions.customizers.QCodeLoader;
 import com.kingsrook.qqq.backend.core.actions.tables.QueryAction;
 import com.kingsrook.qqq.backend.core.context.QContext;
@@ -47,10 +52,9 @@ import com.kingsrook.qqq.backend.core.model.metadata.possiblevalues.QPossibleVal
 import com.kingsrook.qqq.backend.core.model.metadata.possiblevalues.QPossibleValueSource;
 import com.kingsrook.qqq.backend.core.model.metadata.possiblevalues.QPossibleValueSourceType;
 import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
-import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
 import com.kingsrook.qqq.backend.core.utils.StringUtils;
 import com.kingsrook.qqq.backend.core.utils.ValueUtils;
-import org.apache.commons.lang.NotImplementedException;
+import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
 
 
 /*******************************************************************************
@@ -61,6 +65,9 @@ public class SearchPossibleValueSourceAction
 {
    private static final QLogger LOG = QLogger.getLogger(SearchPossibleValueSourceAction.class);
 
+   private static final Set<String> warnedAboutUnexpectedValueField                = Collections.synchronizedSet(new HashSet<>());
+   private static final Set<String> warnedAboutUnexpectedNoOfFieldsToSearchByLabel = Collections.synchronizedSet(new HashSet<>());
+
    private QPossibleValueTranslator possibleValueTranslator;
 
 
@@ -101,47 +108,54 @@ public class SearchPossibleValueSourceAction
 
 
 
+   /***************************************************************************
+    ** record to store "computed" values as part of a possible-value search -
+    ** e.g., ids type-convered, and lower-cased labels.
+    ***************************************************************************/
+   public record PreparedSearchPossibleValueSourceInput(Collection<?> inputIdsAsCorrectType, Collection<String> lowerCaseLabels, String searchTerm) {}
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   public static PreparedSearchPossibleValueSourceInput prepareSearchPossibleValueSourceInput(SearchPossibleValueSourceInput input)
+   {
+      QPossibleValueSource possibleValueSource   = QContext.getQInstance().getPossibleValueSource(input.getPossibleValueSourceName());
+      List<?>              inputIdsAsCorrectType = convertInputIdsToPossibleValueSourceIdType(possibleValueSource, input.getIdList());
+
+      Set<String> lowerCaseLabels = null;
+      if(input.getLabelList() != null)
+      {
+         lowerCaseLabels = input.getLabelList().stream()
+            .filter(Objects::nonNull)
+            .map(l -> l.toLowerCase())
+            .collect(Collectors.toSet());
+      }
+
+      return (new PreparedSearchPossibleValueSourceInput(inputIdsAsCorrectType, lowerCaseLabels, input.getSearchTerm()));
+   }
+
+
+
    /*******************************************************************************
     **
     *******************************************************************************/
    private SearchPossibleValueSourceOutput searchPossibleValueEnum(SearchPossibleValueSourceInput input, QPossibleValueSource possibleValueSource)
    {
+      PreparedSearchPossibleValueSourceInput preparedSearchPossibleValueSourceInput = prepareSearchPossibleValueSourceInput(input);
+
       SearchPossibleValueSourceOutput output      = new SearchPossibleValueSourceOutput();
       List<Serializable>              matchingIds = new ArrayList<>();
 
-      List<?> inputIdsAsCorrectType = convertInputIdsToEnumIdType(possibleValueSource, input.getIdList());
-
       for(QPossibleValue<?> possibleValue : possibleValueSource.getEnumValues())
       {
-         boolean match = false;
-
-         if(input.getIdList() != null)
-         {
-            if(inputIdsAsCorrectType.contains(possibleValue.getId()))
-            {
-               match = true;
-            }
-         }
-         else
-         {
-            if(StringUtils.hasContent(input.getSearchTerm()))
-            {
-               match = (Objects.equals(ValueUtils.getValueAsString(possibleValue.getId()).toLowerCase(), input.getSearchTerm().toLowerCase())
-                  || possibleValue.getLabel().toLowerCase().startsWith(input.getSearchTerm().toLowerCase()));
-            }
-            else
-            {
-               match = true;
-            }
-         }
+         boolean match = doesPossibleValueMatchSearchInput(possibleValue, preparedSearchPossibleValueSourceInput);
 
          if(match)
          {
-            matchingIds.add((Serializable) possibleValue.getId());
+            matchingIds.add(possibleValue.getId());
          }
-
-         // todo - skip & limit?
-         // todo - default filter
       }
 
       List<QPossibleValue<?>> qPossibleValues = possibleValueTranslator.buildTranslatedPossibleValueList(possibleValueSource, matchingIds);
@@ -152,37 +166,95 @@ public class SearchPossibleValueSourceAction
 
 
 
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   public static boolean doesPossibleValueMatchSearchInput(QPossibleValue<?> possibleValue, PreparedSearchPossibleValueSourceInput input)
+   {
+      boolean match = false;
+
+      if(input.inputIdsAsCorrectType() != null)
+      {
+         if(input.inputIdsAsCorrectType().contains(possibleValue.getId()))
+         {
+            match = true;
+         }
+      }
+      else if(input.lowerCaseLabels() != null)
+      {
+         if(input.lowerCaseLabels().contains(possibleValue.getLabel().toLowerCase()))
+         {
+            match = true;
+         }
+      }
+      else
+      {
+         if(StringUtils.hasContent(input.searchTerm()))
+         {
+            match = (Objects.equals(ValueUtils.getValueAsString(possibleValue.getId()).toLowerCase(), input.searchTerm().toLowerCase())
+               || possibleValue.getLabel().toLowerCase().startsWith(input.searchTerm().toLowerCase()));
+         }
+         else
+         {
+            match = true;
+         }
+      }
+      return match;
+   }
+
+
+
    /*******************************************************************************
     ** The input list of ids might come through as a type that isn't the same as
     ** the type of the ids in the enum (e.g., strings from a frontend, integers
-    ** in an enum).  So, this method looks at the first id in the enum, and then
-    ** maps all the inputIds to be of the same type.
+    ** in an enum).  So, this method type-converts them.
     *******************************************************************************/
-   private List<Object> convertInputIdsToEnumIdType(QPossibleValueSource possibleValueSource, List<Serializable> inputIdList)
+   private static List<Object> convertInputIdsToPossibleValueSourceIdType(QPossibleValueSource possibleValueSource, List<Serializable> inputIdList)
    {
       List<Object> rs = new ArrayList<>();
-      if(CollectionUtils.nullSafeIsEmpty(inputIdList))
+
+      if(inputIdList == null)
+      {
+         return (null);
+      }
+      else if(inputIdList.isEmpty())
       {
          return (rs);
       }
 
-      Object anIdFromTheEnum = possibleValueSource.getEnumValues().get(0).getId();
+      QFieldType type = possibleValueSource.getIdType();
 
-      if(anIdFromTheEnum instanceof Integer)
+      for(Serializable inputId : inputIdList)
       {
-         inputIdList.forEach(id -> rs.add(ValueUtils.getValueAsInteger(id)));
-      }
-      else if(anIdFromTheEnum instanceof String)
-      {
-         inputIdList.forEach(id -> rs.add(ValueUtils.getValueAsString(id)));
-      }
-      else if(anIdFromTheEnum instanceof Boolean)
-      {
-         inputIdList.forEach(id -> rs.add(ValueUtils.getValueAsBoolean(id)));
-      }
-      else
-      {
-         LOG.warn("Unexpected type [" + anIdFromTheEnum.getClass().getSimpleName() + "] for ids in enum: " + possibleValueSource.getName());
+         Object properlyTypedId = null;
+         try
+         {
+            if(type.equals(QFieldType.INTEGER))
+            {
+               properlyTypedId = ValueUtils.getValueAsInteger(inputId);
+            }
+            else if(type.isStringLike())
+            {
+               properlyTypedId = ValueUtils.getValueAsString(inputId);
+            }
+            else if(type.equals(QFieldType.BOOLEAN))
+            {
+               properlyTypedId = ValueUtils.getValueAsBoolean(inputId);
+            }
+            else
+            {
+               LOG.warn("Unexpected type [" + type + "] for ids in enum: " + possibleValueSource.getName());
+            }
+         }
+         catch(Exception e)
+         {
+            LOG.debug("Error converting possible value id to expected id type", e, logPair("value", inputId));
+         }
+
+         if(properlyTypedId != null)
+         {
+            rs.add(properlyTypedId);
+         }
       }
 
       return (rs);
@@ -209,6 +281,53 @@ public class SearchPossibleValueSourceAction
       {
          queryFilter.addCriteria(new QFilterCriteria(table.getPrimaryKeyField(), QCriteriaOperator.IN, input.getIdList()));
       }
+      else if(input.getLabelList() != null)
+      {
+         List<String> fieldNames = new ArrayList<>();
+
+         ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+         // the 'value fields' will either be 'id' or 'label' (which means, use the fields from the tableMetaData's label fields) //
+         ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+         for(String valueField : possibleValueSource.getValueFields())
+         {
+            if("id".equals(valueField))
+            {
+               fieldNames.add(table.getPrimaryKeyField());
+            }
+            else if("label".equals(valueField))
+            {
+               if(table.getRecordLabelFields() != null)
+               {
+                  fieldNames.addAll(table.getRecordLabelFields());
+               }
+            }
+            else
+            {
+               String message = "Unexpected valueField defined in possibleValueSource when searching possibleValueSource by label (required: 'id' or 'label')";
+               if(!warnedAboutUnexpectedValueField.contains(possibleValueSource.getName()))
+               {
+                  LOG.warn(message, logPair("valueField", valueField), logPair("possibleValueSource", possibleValueSource.getName()));
+                  warnedAboutUnexpectedValueField.add(possibleValueSource.getName());
+               }
+               output.setWarning(message);
+            }
+         }
+
+         if(fieldNames.size() == 1)
+         {
+            queryFilter.addCriteria(new QFilterCriteria(fieldNames.get(0), QCriteriaOperator.IN, input.getLabelList()));
+         }
+         else
+         {
+            String message = "Unexpected number of fields found for searching possibleValueSource by label (required: 1, found: " + fieldNames.size() + ")";
+            if(!warnedAboutUnexpectedNoOfFieldsToSearchByLabel.contains(possibleValueSource.getName()))
+            {
+               LOG.warn(message);
+               warnedAboutUnexpectedNoOfFieldsToSearchByLabel.add(possibleValueSource.getName());
+            }
+            output.setWarning(message);
+         }
+      }
       else
       {
          String searchTerm = input.getSearchTerm();
@@ -269,8 +388,8 @@ public class SearchPossibleValueSourceAction
          queryFilter = input.getDefaultQueryFilter();
       }
 
-      // todo - skip & limit as params
-      queryFilter.setLimit(250);
+      queryFilter.setLimit(input.getLimit());
+      queryFilter.setSkip(input.getSkip());
 
       queryFilter.setOrderBys(possibleValueSource.getOrderByFields());
 
@@ -288,7 +407,7 @@ public class SearchPossibleValueSourceAction
          fieldName = table.getPrimaryKeyField();
       }
 
-      List<Serializable> ids = queryOutput.getRecords().stream().map(r -> r.getValue(fieldName)).toList();
+      List<Serializable>      ids             = queryOutput.getRecords().stream().map(r -> r.getValue(fieldName)).toList();
       List<QPossibleValue<?>> qPossibleValues = possibleValueTranslator.buildTranslatedPossibleValueList(possibleValueSource, ids);
       output.setResults(qPossibleValues);
 
@@ -301,11 +420,11 @@ public class SearchPossibleValueSourceAction
     **
     *******************************************************************************/
    @SuppressWarnings({ "rawtypes", "unchecked" })
-   private SearchPossibleValueSourceOutput searchPossibleValueCustom(SearchPossibleValueSourceInput input, QPossibleValueSource possibleValueSource)
+   private SearchPossibleValueSourceOutput searchPossibleValueCustom(SearchPossibleValueSourceInput input, QPossibleValueSource possibleValueSource) throws QException
    {
       try
       {
-         QCustomPossibleValueProvider customPossibleValueProvider = QCodeLoader.getCustomPossibleValueProvider(possibleValueSource);
+         QCustomPossibleValueProvider customPossibleValueProvider = QCodeLoader.getAdHoc(QCustomPossibleValueProvider.class, possibleValueSource.getCustomCodeReference());
          List<QPossibleValue<?>>      possibleValues              = customPossibleValueProvider.search(input);
 
          SearchPossibleValueSourceOutput output = new SearchPossibleValueSourceOutput();
@@ -314,11 +433,10 @@ public class SearchPossibleValueSourceAction
       }
       catch(Exception e)
       {
-         // LOG.warn("Error sending [" + value + "] for field [" + field + "] through custom code for PVS [" + field.getPossibleValueSourceName() + "]", e);
+         String message = "Error searching custom possible value source [" + input.getPossibleValueSourceName() + "]";
+         LOG.warn(message, e);
+         throw (new QException(message, e));
       }
-
-      throw new NotImplementedException("Not impleemnted");
-      // return (null);
    }
 
 }

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

@@ -29,7 +29,7 @@ import com.kingsrook.qqq.backend.core.model.metadata.QInstance;
 
 /*******************************************************************************
  ** Version of AbstractQQQApplication that assumes all meta-data is produced
- ** by MetaDataProducers in a single package.
+ ** by MetaDataProducers in (or under) a single package.
  *******************************************************************************/
 public abstract class AbstractMetaDataProducerBasedQQQApplication extends AbstractQQQApplication
 {

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

@@ -0,0 +1,61 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2025.  Kingsrook, LLC
+ * 651 N Broad St Ste 205 # 6917 | Middletown DE 19709 | United States
+ * contact@kingsrook.com
+ * https://github.com/Kingsrook/
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.kingsrook.qqq.backend.core.instances;
+
+
+import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.instances.loaders.MetaDataLoaderHelper;
+import com.kingsrook.qqq.backend.core.model.metadata.QInstance;
+
+
+/*******************************************************************************
+ ** Version of AbstractQQQApplication that assumes all meta-data is defined in
+ ** config files (yaml, json, etc) under a given directory path.
+ *******************************************************************************/
+public class ConfigFilesBasedQQQApplication extends AbstractQQQApplication
+{
+   private final String path;
+
+
+
+   /*******************************************************************************
+    ** Constructor
+    **
+    *******************************************************************************/
+   public ConfigFilesBasedQQQApplication(String path)
+   {
+      this.path = path;
+   }
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   @Override
+   public QInstance defineQInstance() throws QException
+   {
+      QInstance qInstance = new QInstance();
+      MetaDataLoaderHelper.processAllMetaDataFilesInDirectory(qInstance, path);
+      return (qInstance);
+   }
+}

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

@@ -0,0 +1,67 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2025.  Kingsrook, LLC
+ * 651 N Broad St Ste 205 # 6917 | Middletown DE 19709 | United States
+ * contact@kingsrook.com
+ * https://github.com/Kingsrook/
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.kingsrook.qqq.backend.core.instances;
+
+
+/*******************************************************************************
+ ** Version of AbstractQQQApplication that assumes all meta-data is produced
+ ** by MetaDataProducers in (or under) a single package (where you can pass that
+ ** package into the constructor, vs. the abstract base class, where you extend
+ ** it and override the getMetaDataPackageName method.
+ *******************************************************************************/
+public class MetaDataProducerBasedQQQApplication extends AbstractMetaDataProducerBasedQQQApplication
+{
+   private final String metaDataPackageName;
+
+
+
+   /*******************************************************************************
+    ** Constructor
+    **
+    *******************************************************************************/
+   public MetaDataProducerBasedQQQApplication(String metaDataPackageName)
+   {
+      this.metaDataPackageName = metaDataPackageName;
+   }
+
+
+
+   /*******************************************************************************
+    ** Constructor
+    **
+    *******************************************************************************/
+   public MetaDataProducerBasedQQQApplication(Class<?> aClassInMetaDataPackage)
+   {
+      this(aClassInMetaDataPackage.getPackageName());
+   }
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   @Override
+   public String getMetaDataPackageName()
+   {
+      return (this.metaDataPackageName);
+   }
+}

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

@@ -23,7 +23,11 @@ package com.kingsrook.qqq.backend.core.instances;
 
 
 import java.io.Serializable;
+import java.lang.reflect.Method;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -31,21 +35,27 @@ import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
 import java.util.stream.Collectors;
+import com.kingsrook.qqq.backend.core.actions.customizers.QCodeLoader;
 import com.kingsrook.qqq.backend.core.actions.metadata.JoinGraph;
 import com.kingsrook.qqq.backend.core.actions.permissions.BulkTableActionProcessPermissionChecker;
+import com.kingsrook.qqq.backend.core.actions.values.QCustomPossibleValueProvider;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.instances.enrichment.plugins.QInstanceEnricherPluginInterface;
 import com.kingsrook.qqq.backend.core.logging.QLogger;
 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.code.QCodeReference;
 import com.kingsrook.qqq.backend.core.model.metadata.dashboard.QWidgetMetaDataInterface;
 import com.kingsrook.qqq.backend.core.model.metadata.fields.AdornmentType;
+import com.kingsrook.qqq.backend.core.model.metadata.fields.AdornmentType.FileUploadAdornment;
 import com.kingsrook.qqq.backend.core.model.metadata.fields.DynamicDefaultValueBehavior;
 import com.kingsrook.qqq.backend.core.model.metadata.fields.FieldAdornment;
 import com.kingsrook.qqq.backend.core.model.metadata.fields.QFieldMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.fields.QFieldType;
+import com.kingsrook.qqq.backend.core.model.metadata.joins.QJoinMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.layout.QAppChildMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.layout.QAppMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.layout.QAppSection;
@@ -54,6 +64,7 @@ import com.kingsrook.qqq.backend.core.model.metadata.permissions.MetaDataWithPer
 import com.kingsrook.qqq.backend.core.model.metadata.permissions.QPermissionRules;
 import com.kingsrook.qqq.backend.core.model.metadata.possiblevalues.QPossibleValueSource;
 import com.kingsrook.qqq.backend.core.model.metadata.possiblevalues.QPossibleValueSourceType;
+import com.kingsrook.qqq.backend.core.model.metadata.processes.QBackendStepMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.processes.QComponentType;
 import com.kingsrook.qqq.backend.core.model.metadata.processes.QFrontendComponentMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.processes.QFrontendStepMetaData;
@@ -75,13 +86,20 @@ import com.kingsrook.qqq.backend.core.processes.implementations.bulk.edit.BulkEd
 import com.kingsrook.qqq.backend.core.processes.implementations.bulk.edit.BulkEditTransformStep;
 import com.kingsrook.qqq.backend.core.processes.implementations.bulk.insert.BulkInsertExtractStep;
 import com.kingsrook.qqq.backend.core.processes.implementations.bulk.insert.BulkInsertLoadStep;
+import com.kingsrook.qqq.backend.core.processes.implementations.bulk.insert.BulkInsertPrepareFileMappingStep;
+import com.kingsrook.qqq.backend.core.processes.implementations.bulk.insert.BulkInsertPrepareFileUploadStep;
+import com.kingsrook.qqq.backend.core.processes.implementations.bulk.insert.BulkInsertPrepareValueMappingStep;
+import com.kingsrook.qqq.backend.core.processes.implementations.bulk.insert.BulkInsertReceiveFileMappingStep;
+import com.kingsrook.qqq.backend.core.processes.implementations.bulk.insert.BulkInsertReceiveValueMappingStep;
 import com.kingsrook.qqq.backend.core.processes.implementations.bulk.insert.BulkInsertTransformStep;
 import com.kingsrook.qqq.backend.core.processes.implementations.etl.streamedwithfrontend.ExtractViaQueryStep;
 import com.kingsrook.qqq.backend.core.processes.implementations.etl.streamedwithfrontend.StreamedETLWithFrontendProcess;
 import com.kingsrook.qqq.backend.core.scheduler.QScheduleManager;
+import com.kingsrook.qqq.backend.core.utils.ClassPathUtils;
 import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
 import com.kingsrook.qqq.backend.core.utils.ListingHash;
 import com.kingsrook.qqq.backend.core.utils.StringUtils;
+import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
 
 
 /*******************************************************************************
@@ -107,6 +125,8 @@ public class QInstanceEnricher
    //////////////////////////////////////////////////////////////////////////////////////////////////
    private static final Map<String, String> labelMappings = new LinkedHashMap<>();
 
+   private static ListingHash<Class<?>, QInstanceEnricherPluginInterface<?>> enricherPlugins = new ListingHash<>();
+
 
 
    /*******************************************************************************
@@ -168,6 +188,7 @@ public class QInstanceEnricher
       }
 
       enrichJoins();
+      enrichInstance();
 
       //////////////////////////////////////////////////////////////////////////////
       // if the instance DOES have 1 or more scheduler, but no schedulable types, //
@@ -184,6 +205,16 @@ public class QInstanceEnricher
 
 
 
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   private void enrichInstance()
+   {
+      runPlugins(QInstance.class, qInstance, qInstance);
+   }
+
+
+
    /*******************************************************************************
     **
     *******************************************************************************/
@@ -248,6 +279,14 @@ public class QInstanceEnricher
                }
             }
          }
+
+         ///////////////////////////////////////////
+         // run plugins on joins if there are any //
+         ///////////////////////////////////////////
+         for(QJoinMetaData join : qInstance.getJoins().values())
+         {
+            runPlugins(QJoinMetaData.class, join, qInstance);
+         }
       }
       catch(Exception e)
       {
@@ -263,6 +302,7 @@ public class QInstanceEnricher
    private void enrichWidget(QWidgetMetaDataInterface widgetMetaData)
    {
       enrichPermissionRules(widgetMetaData);
+      runPlugins(QWidgetMetaDataInterface.class, widgetMetaData, qInstance);
    }
 
 
@@ -273,6 +313,7 @@ public class QInstanceEnricher
    private void enrichBackend(QBackendMetaData qBackendMetaData)
    {
       qBackendMetaData.enrich();
+      runPlugins(QBackendMetaData.class, qBackendMetaData, qInstance);
    }
 
 
@@ -289,7 +330,21 @@ public class QInstanceEnricher
 
       if(table.getFields() != null)
       {
-         table.getFields().values().forEach(this::enrichField);
+         for(Map.Entry<String, QFieldMetaData> entry : table.getFields().entrySet())
+         {
+            String         name  = entry.getKey();
+            QFieldMetaData field = entry.getValue();
+
+            ////////////////////////////////////////////////////////////////////////////
+            // in case the field wasn't given a name, use its key from the fields map //
+            ////////////////////////////////////////////////////////////////////////////
+            if(!StringUtils.hasContent(field.getName()))
+            {
+               field.setName(name);
+            }
+
+            enrichField(field);
+         }
 
          for(QSupplementalTableMetaData supplementalTableMetaData : CollectionUtils.nonNullMap(table.getSupplementalMetaData()).values())
          {
@@ -313,6 +368,7 @@ public class QInstanceEnricher
 
       enrichPermissionRules(table);
       enrichAuditRules(table);
+      runPlugins(QTableMetaData.class, table, qInstance);
    }
 
 
@@ -403,6 +459,7 @@ public class QInstanceEnricher
       }
 
       enrichPermissionRules(process);
+      runPlugins(QProcessMetaData.class, process, qInstance);
    }
 
 
@@ -524,6 +581,8 @@ public class QInstanceEnricher
             field.withBehavior(DynamicDefaultValueBehavior.MODIFY_DATE);
          }
       }
+
+      runPlugins(QFieldMetaData.class, field, qInstance);
    }
 
 
@@ -595,6 +654,7 @@ public class QInstanceEnricher
       ensureAppSectionMembersAreAppChildren(app);
 
       enrichPermissionRules(app);
+      runPlugins(QAppMetaData.class, app, qInstance);
    }
 
 
@@ -742,6 +802,7 @@ public class QInstanceEnricher
       }
 
       enrichPermissionRules(report);
+      runPlugins(QReportMetaData.class, report, qInstance);
    }
 
 
@@ -833,7 +894,7 @@ public class QInstanceEnricher
    /*******************************************************************************
     **
     *******************************************************************************/
-   private void defineTableBulkInsert(QInstance qInstance, QTableMetaData table, String processName)
+   public void defineTableBulkInsert(QInstance qInstance, QTableMetaData table, String processName)
    {
       Map<String, Serializable> values = new HashMap<>();
       values.put(StreamedETLWithFrontendProcess.FIELD_DESTINATION_TABLE, table.getName());
@@ -845,6 +906,7 @@ public class QInstanceEnricher
             values
          )
          .withName(processName)
+         .withIcon(new QIcon().withName("library_add"))
          .withLabel(table.getLabel() + " Bulk Insert")
          .withTableName(table.getName())
          .withIsHidden(true)
@@ -875,18 +937,76 @@ public class QInstanceEnricher
          .map(QFieldMetaData::getLabel)
          .collect(Collectors.joining(", "));
 
+      QBackendStepMetaData prepareFileUploadStep = new QBackendStepMetaData()
+         .withName("prepareFileUpload")
+         .withCode(new QCodeReference(BulkInsertPrepareFileUploadStep.class));
+
       QFrontendStepMetaData uploadScreen = new QFrontendStepMetaData()
          .withName("upload")
          .withLabel("Upload File")
-         .withFormField(new QFieldMetaData("theFile", QFieldType.BLOB).withLabel(table.getLabel() + " File").withIsRequired(true))
-         .withComponent(new QFrontendComponentMetaData()
-            .withType(QComponentType.HELP_TEXT)
-            .withValue("previewText", "file upload instructions")
-            .withValue("text", "Upload a CSV file with the following columns:\n" + fieldsForHelpText))
+         .withFormField(new QFieldMetaData("theFile", QFieldType.BLOB)
+            .withFieldAdornment(FileUploadAdornment.newFieldAdornment()
+               .withValue(FileUploadAdornment.formatDragAndDrop())
+               .withValue(FileUploadAdornment.widthFull()))
+            .withLabel(table.getLabel() + " File")
+            .withIsRequired(true))
+         .withComponent(new QFrontendComponentMetaData().withType(QComponentType.HTML))
          .withComponent(new QFrontendComponentMetaData().withType(QComponentType.EDIT_FORM));
 
-      process.addStep(0, uploadScreen);
-      process.getFrontendStep("review").setRecordListFields(editableFields);
+      QBackendStepMetaData prepareFileMappingStep = new QBackendStepMetaData()
+         .withName("prepareFileMapping")
+         .withCode(new QCodeReference(BulkInsertPrepareFileMappingStep.class));
+
+      QFrontendStepMetaData fileMappingScreen = new QFrontendStepMetaData()
+         .withName("fileMapping")
+         .withLabel("File Mapping")
+         .withBackStepName("prepareFileUpload")
+         .withComponent(new QFrontendComponentMetaData().withType(QComponentType.BULK_LOAD_FILE_MAPPING_FORM))
+         .withFormField(new QFieldMetaData("hasHeaderRow", QFieldType.BOOLEAN))
+         .withFormField(new QFieldMetaData("layout", QFieldType.STRING)); // is actually PVS, but, this field is only added to help support helpContent, so :shrug:
+
+      QBackendStepMetaData receiveFileMappingStep = new QBackendStepMetaData()
+         .withName("receiveFileMapping")
+         .withCode(new QCodeReference(BulkInsertReceiveFileMappingStep.class));
+
+      QBackendStepMetaData prepareValueMappingStep = new QBackendStepMetaData()
+         .withName("prepareValueMapping")
+         .withCode(new QCodeReference(BulkInsertPrepareValueMappingStep.class));
+
+      QFrontendStepMetaData valueMappingScreen = new QFrontendStepMetaData()
+         .withName("valueMapping")
+         .withLabel("Value Mapping")
+         .withBackStepName("prepareFileMapping")
+         .withComponent(new QFrontendComponentMetaData().withType(QComponentType.BULK_LOAD_VALUE_MAPPING_FORM));
+
+      QBackendStepMetaData receiveValueMappingStep = new QBackendStepMetaData()
+         .withName("receiveValueMapping")
+         .withCode(new QCodeReference(BulkInsertReceiveValueMappingStep.class));
+
+      int i = 0;
+      process.addStep(i++, prepareFileUploadStep);
+      process.addStep(i++, uploadScreen);
+
+      process.addStep(i++, prepareFileMappingStep);
+      process.addStep(i++, fileMappingScreen);
+      process.addStep(i++, receiveFileMappingStep);
+
+      process.addStep(i++, prepareValueMappingStep);
+      process.addStep(i++, valueMappingScreen);
+      process.addStep(i++, receiveValueMappingStep);
+
+      process.getFrontendStep(StreamedETLWithFrontendProcess.STEP_NAME_REVIEW).setRecordListFields(editableFields);
+
+      //////////////////////////////////////////////////////////////////////////////////////////
+      // put the bulk-load profile form (e.g., for saving it) on the review & result screens) //
+      //////////////////////////////////////////////////////////////////////////////////////////
+      process.getFrontendStep(StreamedETLWithFrontendProcess.STEP_NAME_REVIEW)
+         .withBackStepName("prepareFileMapping")
+         .getComponents().add(0, new QFrontendComponentMetaData().withType(QComponentType.BULK_LOAD_PROFILE_FORM));
+
+      process.getFrontendStep(StreamedETLWithFrontendProcess.STEP_NAME_RESULT)
+         .getComponents().add(0, new QFrontendComponentMetaData().withType(QComponentType.BULK_LOAD_PROFILE_FORM));
+
       qInstance.addProcess(process);
    }
 
@@ -1281,6 +1401,137 @@ public class QInstanceEnricher
             }
          }
 
+         if(possibleValueSource.getIdType() == null)
+         {
+            QTableMetaData table = qInstance.getTable(possibleValueSource.getTableName());
+            if(table != null)
+            {
+               String         primaryKeyField         = table.getPrimaryKeyField();
+               QFieldMetaData primaryKeyFieldMetaData = table.getFields().get(primaryKeyField);
+               if(primaryKeyFieldMetaData != null)
+               {
+                  possibleValueSource.setIdType(primaryKeyFieldMetaData.getType());
+               }
+            }
+         }
+      }
+      else if(QPossibleValueSourceType.ENUM.equals(possibleValueSource.getType()))
+      {
+         if(possibleValueSource.getIdType() == null)
+         {
+            if(CollectionUtils.nullSafeHasContents(possibleValueSource.getEnumValues()))
+            {
+               Object id = possibleValueSource.getEnumValues().get(0).getId();
+               try
+               {
+                  possibleValueSource.setIdType(QFieldType.fromClass(id.getClass()));
+               }
+               catch(Exception e)
+               {
+                  LOG.warn("Error enriching possible value source with idType based on first enum value", e, logPair("possibleValueSource", possibleValueSource.getName()), logPair("id", id));
+               }
+            }
+         }
+      }
+      else if(QPossibleValueSourceType.CUSTOM.equals(possibleValueSource.getType()))
+      {
+         if(possibleValueSource.getIdType() == null)
+         {
+            try
+            {
+               QCustomPossibleValueProvider<?> customPossibleValueProvider = QCodeLoader.getAdHoc(QCustomPossibleValueProvider.class, possibleValueSource.getCustomCodeReference());
+
+               Method getPossibleValueMethod = customPossibleValueProvider.getClass().getDeclaredMethod("getPossibleValue", Serializable.class);
+               Type   returnType             = getPossibleValueMethod.getGenericReturnType();
+               Type   idType                 = ((ParameterizedType) returnType).getActualTypeArguments()[0];
+
+               if(idType instanceof Class<?> c)
+               {
+                  possibleValueSource.setIdType(QFieldType.fromClass(c));
+               }
+            }
+            catch(Exception e)
+            {
+               LOG.warn("Error enriching possible value source with idType based on first custom value", e, logPair("possibleValueSource", possibleValueSource.getName()));
+            }
+         }
+      }
+
+      runPlugins(QPossibleValueSource.class, possibleValueSource, qInstance);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public static void addEnricherPlugin(QInstanceEnricherPluginInterface<?> plugin)
+   {
+      Optional<Method> enrichMethod = Arrays.stream(plugin.getClass().getDeclaredMethods())
+         .filter(m -> m.getName().equals("enrich")
+            && m.getParameterCount() == 2
+            && !m.getParameterTypes()[0].equals(Object.class)
+            && m.getParameterTypes()[1].equals(QInstance.class)
+         ).findFirst();
+
+      if(enrichMethod.isPresent())
+      {
+         Class<?> parameterType = enrichMethod.get().getParameterTypes()[0];
+         enricherPlugins.add(parameterType, plugin);
+      }
+      else
+      {
+         LOG.warn("Could not find enrich method on enricher plugin [" + plugin.getClass().getName() + "] (to infer type being enriched) - this plugin will not be used.");
+      }
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public static void removeAllEnricherPlugins()
+   {
+      enricherPlugins.clear();
+   }
+
+
+
+   /***************************************************************************
+    ** scan the classpath for classes in the specified package name which
+    ** implement the QInstanceEnricherPluginInterface - any found get added
+    ***************************************************************************/
+   public static void discoverAndAddPluginsInPackage(String packageName) throws QException
+   {
+      try
+      {
+         for(Class<?> aClass : ClassPathUtils.getClassesInPackage(packageName))
+         {
+            if(QInstanceEnricherPluginInterface.class.isAssignableFrom(aClass))
+            {
+               QInstanceEnricherPluginInterface<?> plugin = (QInstanceEnricherPluginInterface<?>) aClass.getConstructor().newInstance();
+               addEnricherPlugin(plugin);
+            }
+         }
+      }
+      catch(Exception e)
+      {
+         throw (new QException("Error discovering and adding enricher plugins in package [" + packageName + "]", e));
+      }
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   private <T> void runPlugins(Class<T> c, T t, QInstance qInstance)
+   {
+      for(QInstanceEnricherPluginInterface<?> plugin : CollectionUtils.nonNullList(enricherPlugins.get(c)))
+      {
+         @SuppressWarnings("unchecked")
+         QInstanceEnricherPluginInterface<T> castedPlugin = (QInstanceEnricherPluginInterface<T>) plugin;
+         castedPlugin.enrich(t, qInstance);
       }
    }
 

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

@@ -30,7 +30,6 @@ import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
 import com.kingsrook.qqq.backend.core.actions.tables.QueryAction;
-import com.kingsrook.qqq.backend.core.context.QContext;
 import com.kingsrook.qqq.backend.core.logging.QLogger;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryInput;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryOutput;
@@ -111,7 +110,7 @@ public class QInstanceHelpContentManager
             }
             else
             {
-               LOG.info("Discarding help content with key that does not contain name:value format", logPair("key", key), logPair("id", record.getValue("id")));
+               LOG.info("Discarding help content with key-part that does not contain name:value format", logPair("key", key), logPair("part", part), logPair("id", record.getValue("id")));
             }
          }
 
@@ -150,19 +149,19 @@ public class QInstanceHelpContentManager
          ///////////////////////////////////////////////////////////////////////////////////
          if(StringUtils.hasContent(tableName))
          {
-            processHelpContentForTable(key, tableName, sectionName, fieldName, slotName, roles, helpContent);
+            processHelpContentForTable(qInstance, key, tableName, sectionName, fieldName, slotName, roles, helpContent);
          }
          else if(StringUtils.hasContent(processName))
          {
-            processHelpContentForProcess(key, processName, fieldName, stepName, roles, helpContent);
+            processHelpContentForProcess(qInstance, key, processName, fieldName, stepName, roles, helpContent);
          }
          else if(StringUtils.hasContent(widgetName))
          {
-            processHelpContentForWidget(key, widgetName, slotName, roles, helpContent);
+            processHelpContentForWidget(qInstance, key, widgetName, slotName, roles, helpContent);
          }
          else if(nameValuePairs.containsKey("instanceLevel"))
          {
-            processHelpContentForInstance(key, slotName, roles, helpContent);
+            processHelpContentForInstance(qInstance, key, slotName, roles, helpContent);
          }
       }
       catch(Exception e)
@@ -176,9 +175,9 @@ public class QInstanceHelpContentManager
    /*******************************************************************************
     **
     *******************************************************************************/
-   private static void processHelpContentForTable(String key, String tableName, String sectionName, String fieldName, String slotName, Set<HelpRole> roles, QHelpContent helpContent)
+   private static void processHelpContentForTable(QInstance qInstance, String key, String tableName, String sectionName, String fieldName, String slotName, Set<HelpRole> roles, QHelpContent helpContent)
    {
-      QTableMetaData table = QContext.getQInstance().getTable(tableName);
+      QTableMetaData table = qInstance.getTable(tableName);
       if(table == null)
       {
          LOG.info("Unrecognized table in help content", logPair("key", key));
@@ -246,9 +245,30 @@ public class QInstanceHelpContentManager
    /*******************************************************************************
     **
     *******************************************************************************/
-   private static void processHelpContentForProcess(String key, String processName, String fieldName, String stepName, Set<HelpRole> roles, QHelpContent helpContent)
+   private static void processHelpContentForProcess(QInstance qInstance, String key, String processName, String fieldName, String stepName, Set<HelpRole> roles, QHelpContent helpContent)
    {
-      QProcessMetaData process = QContext.getQInstance().getProcess(processName);
+      if(processName.startsWith("*") && processName.length() > 1)
+      {
+         boolean anyMatched = false;
+         String subName = processName.substring(1);
+         for(QProcessMetaData process : qInstance.getProcesses().values())
+         {
+            if(process.getName().endsWith(subName))
+            {
+               anyMatched = true;
+               processHelpContentForProcess(qInstance, key, process.getName(), fieldName, stepName, roles, helpContent);
+            }
+         }
+
+         if(!anyMatched)
+         {
+            LOG.info("Wildcard process name did not match any processes in help content", logPair("key", key));
+         }
+
+         return;
+      }
+
+      QProcessMetaData process = qInstance.getProcess(processName);
       if(process == null)
       {
          LOG.info("Unrecognized process in help content", logPair("key", key));
@@ -306,9 +326,9 @@ public class QInstanceHelpContentManager
    /*******************************************************************************
     **
     *******************************************************************************/
-   private static void processHelpContentForWidget(String key, String widgetName, String slotName, Set<HelpRole> roles, QHelpContent helpContent)
+   private static void processHelpContentForWidget(QInstance qInstance, String key, String widgetName, String slotName, Set<HelpRole> roles, QHelpContent helpContent)
    {
-      QWidgetMetaDataInterface widget = QContext.getQInstance().getWidget(widgetName);
+      QWidgetMetaDataInterface widget = qInstance.getWidget(widgetName);
       if(!StringUtils.hasContent(slotName))
       {
          LOG.info("Missing slot name in help content", logPair("key", key));
@@ -335,7 +355,7 @@ public class QInstanceHelpContentManager
    /*******************************************************************************
     **
     *******************************************************************************/
-   private static void processHelpContentForInstance(String key, String slotName, Set<HelpRole> roles, QHelpContent helpContent)
+   private static void processHelpContentForInstance(QInstance qInstance, String key, String slotName, Set<HelpRole> roles, QHelpContent helpContent)
    {
       if(!StringUtils.hasContent(slotName))
       {
@@ -345,11 +365,11 @@ public class QInstanceHelpContentManager
       {
          if(helpContent != null)
          {
-            QContext.getQInstance().withHelpContent(slotName, helpContent);
+            qInstance.withHelpContent(slotName, helpContent);
          }
          else
          {
-            QContext.getQInstance().removeHelpContent(slotName, roles);
+            qInstance.removeHelpContent(slotName, roles);
          }
       }
    }

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

@@ -37,12 +37,15 @@ import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
 import java.util.TimeZone;
+import java.util.function.Function;
 import java.util.function.Supplier;
+import java.util.stream.Collectors;
 import java.util.stream.Stream;
 import com.kingsrook.qqq.backend.core.actions.automation.RecordAutomationHandler;
 import com.kingsrook.qqq.backend.core.actions.customizers.TableCustomizers;
 import com.kingsrook.qqq.backend.core.actions.dashboard.widgets.AbstractWidgetRenderer;
 import com.kingsrook.qqq.backend.core.actions.metadata.JoinGraph;
+import com.kingsrook.qqq.backend.core.actions.metadata.MetaDataActionCustomizerInterface;
 import com.kingsrook.qqq.backend.core.actions.metadata.MetaDataFilterInterface;
 import com.kingsrook.qqq.backend.core.actions.processes.BackendStep;
 import com.kingsrook.qqq.backend.core.actions.reporting.customizers.ReportCustomRecordSourceInterface;
@@ -61,6 +64,7 @@ import com.kingsrook.qqq.backend.core.model.metadata.QSupplementalInstanceMetaDa
 import com.kingsrook.qqq.backend.core.model.metadata.authentication.QAuthenticationMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.automation.QAutomationProviderMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.code.QCodeReference;
+import com.kingsrook.qqq.backend.core.model.metadata.code.QCodeReferenceLambda;
 import com.kingsrook.qqq.backend.core.model.metadata.code.QCodeType;
 import com.kingsrook.qqq.backend.core.model.metadata.dashboard.ParentWidgetMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.dashboard.QWidgetMetaDataInterface;
@@ -70,6 +74,7 @@ import com.kingsrook.qqq.backend.core.model.metadata.fields.FieldBehavior;
 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.joins.JoinOn;
+import com.kingsrook.qqq.backend.core.model.metadata.joins.JoinType;
 import com.kingsrook.qqq.backend.core.model.metadata.joins.QJoinMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.layout.QAppChildMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.layout.QAppMetaData;
@@ -107,12 +112,16 @@ import com.kingsrook.qqq.backend.core.model.metadata.tables.automation.Automatio
 import com.kingsrook.qqq.backend.core.model.metadata.tables.automation.QTableAutomationDetails;
 import com.kingsrook.qqq.backend.core.model.metadata.tables.cache.CacheOf;
 import com.kingsrook.qqq.backend.core.model.metadata.tables.cache.CacheUseCase;
+import com.kingsrook.qqq.backend.core.model.metadata.variants.BackendVariantSetting;
+import com.kingsrook.qqq.backend.core.model.metadata.variants.BackendVariantsConfig;
 import com.kingsrook.qqq.backend.core.modules.authentication.QAuthenticationModuleCustomizerInterface;
 import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
 import com.kingsrook.qqq.backend.core.utils.ListingHash;
 import com.kingsrook.qqq.backend.core.utils.StringUtils;
 import com.kingsrook.qqq.backend.core.utils.ValueUtils;
+import com.kingsrook.qqq.backend.core.utils.lambdas.UnsafeFunction;
 import com.kingsrook.qqq.backend.core.utils.lambdas.UnsafeLambda;
+import org.apache.commons.lang.BooleanUtils;
 import org.quartz.CronExpression;
 import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
 
@@ -135,6 +144,8 @@ public class QInstanceValidator
 
    private static ListingHash<Class<?>, QInstanceValidatorPluginInterface<?>> validatorPlugins = new ListingHash<>();
 
+   private JoinGraph joinGraph = null;
+
    private List<String> errors = new ArrayList<>();
 
 
@@ -162,8 +173,7 @@ public class QInstanceValidator
       // 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. //
       /////////////////////////////////////////////////////////////////////////////////////////////////////
-      JoinGraph joinGraph = null;
-      long      start     = System.currentTimeMillis();
+      long start = System.currentTimeMillis();
       try
       {
          /////////////////////////////////////////////////////////////////////////////////////////////////
@@ -172,7 +182,7 @@ public class QInstanceValidator
          // TODO - possible point of customization (use a different enricher, or none, or pass it options).
          QInstanceEnricher qInstanceEnricher = new QInstanceEnricher(qInstance);
          qInstanceEnricher.enrich();
-         joinGraph = qInstanceEnricher.getJoinGraph();
+         this.joinGraph = qInstanceEnricher.getJoinGraph();
       }
       catch(Exception e)
       {
@@ -237,6 +247,11 @@ public class QInstanceValidator
       {
          validateSimpleCodeReference("Instance metaDataFilter ", qInstance.getMetaDataFilter(), MetaDataFilterInterface.class);
       }
+
+      if(qInstance.getMetaDataActionCustomizer() != null)
+      {
+         validateSimpleCodeReference("Instance metaDataActionCustomizer ", qInstance.getMetaDataActionCustomizer(), MetaDataActionCustomizerInterface.class);
+      }
    }
 
 
@@ -372,8 +387,8 @@ public class QInstanceValidator
          assertCondition(join.getType() != null, "Missing type for join: " + joinName);
          assertCondition(CollectionUtils.nullSafeHasContents(join.getJoinOns()), "Missing joinOns for join: " + joinName);
 
-         boolean leftTableExists  = assertCondition(qInstance.getTable(join.getLeftTable()) != null, "Left-table name " + join.getLeftTable() + " join " + joinName + " is not a defined table in this instance.");
-         boolean rightTableExists = assertCondition(qInstance.getTable(join.getRightTable()) != null, "Right-table name " + join.getRightTable() + " join " + joinName + " is not a defined table in this instance.");
+         boolean leftTableExists  = assertCondition(qInstance.getTable(join.getLeftTable()) != null, "Left-table name " + join.getLeftTable() + " in join " + joinName + " is not a defined table in this instance.");
+         boolean rightTableExists = assertCondition(qInstance.getTable(join.getRightTable()) != null, "Right-table name " + join.getRightTable() + " in join " + joinName + " is not a defined table in this instance.");
 
          for(JoinOn joinOn : CollectionUtils.nonNullList(join.getJoinOns()))
          {
@@ -542,6 +557,60 @@ public class QInstanceValidator
          {
             assertCondition(Objects.equals(backendName, backend.getName()), "Inconsistent naming for backend: " + backendName + "/" + backend.getName() + ".");
 
+            ///////////////////////
+            // validate variants //
+            ///////////////////////
+            BackendVariantsConfig backendVariantsConfig = backend.getBackendVariantsConfig();
+            if(BooleanUtils.isTrue(backend.getUsesVariants()))
+            {
+               if(assertCondition(backendVariantsConfig != null, "Missing backendVariantsConfig in backend [" + backendName + "] which is marked as usesVariants"))
+               {
+                  assertCondition(StringUtils.hasContent(backendVariantsConfig.getVariantTypeKey()), "Missing variantTypeKey in backendVariantsConfig in [" + backendName + "]");
+
+                  String         optionsTableName = backendVariantsConfig.getOptionsTableName();
+                  QTableMetaData optionsTable     = qInstance.getTable(optionsTableName);
+                  if(assertCondition(StringUtils.hasContent(optionsTableName), "Missing optionsTableName in backendVariantsConfig in [" + backendName + "]"))
+                  {
+                     if(assertCondition(optionsTable != null, "Unrecognized optionsTableName [" + optionsTableName + "] in backendVariantsConfig in [" + backendName + "]"))
+                     {
+                        QQueryFilter optionsFilter = backendVariantsConfig.getOptionsFilter();
+                        if(optionsFilter != null)
+                        {
+                           validateQueryFilter(qInstance, "optionsFilter in backendVariantsConfig in backend [" + backendName + "]: ", optionsTable, optionsFilter, null);
+                        }
+                     }
+                  }
+
+                  Map<BackendVariantSetting, String> backendSettingSourceFieldNameMap = backendVariantsConfig.getBackendSettingSourceFieldNameMap();
+                  if(assertCondition(CollectionUtils.nullSafeHasContents(backendSettingSourceFieldNameMap), "Missing or empty backendSettingSourceFieldNameMap in backendVariantsConfig in [" + backendName + "]"))
+                  {
+                     ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                     // only validate field names in the backendSettingSourceFieldNameMap if there is NOT a variantRecordSupplier //
+                     // (the idea being, that the supplier might be building a record with fieldNames that aren't in the table... //
+                     ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                     if(optionsTable != null && backendVariantsConfig.getVariantRecordLookupFunction() == null)
+                     {
+                        for(Map.Entry<BackendVariantSetting, String> entry : backendSettingSourceFieldNameMap.entrySet())
+                        {
+                           assertCondition(optionsTable.getFields().containsKey(entry.getValue()), "Unrecognized fieldName [" + entry.getValue() + "] in backendSettingSourceFieldNameMap in backendVariantsConfig in [" + backendName + "]");
+                        }
+                     }
+                  }
+
+                  if(backendVariantsConfig.getVariantRecordLookupFunction() != null)
+                  {
+                     validateSimpleCodeReference("VariantRecordSupplier in backendVariantsConfig in backend [" + backendName + "]: ", backendVariantsConfig.getVariantRecordLookupFunction(), UnsafeFunction.class, Function.class);
+                  }
+               }
+            }
+            else
+            {
+               assertCondition(backendVariantsConfig == null, "Should not have a backendVariantsConfig in backend [" + backendName + "] which is not marked as usesVariants");
+            }
+
+            ///////////////////////////////////////////
+            // let the backend do its own validation //
+            ///////////////////////////////////////////
             backend.performValidation(this);
 
             runPlugins(QBackendMetaData.class, backend, qInstance);
@@ -576,13 +645,15 @@ public class QInstanceValidator
    private void validateAuthentication(QInstance qInstance)
    {
       QAuthenticationMetaData authentication = qInstance.getAuthentication();
-      if(authentication != null)
+      if(assertCondition(authentication != null, "Authentication MetaData must be defined."))
       {
          if(authentication.getCustomizer() != null)
          {
             validateSimpleCodeReference("Instance Authentication meta data customizer ", authentication.getCustomizer(), QAuthenticationModuleCustomizerInterface.class);
          }
 
+         authentication.validate(qInstance, this);
+
          runPlugins(QAuthenticationMetaData.class, authentication, qInstance);
       }
    }
@@ -779,15 +850,38 @@ public class QInstanceValidator
       {
          if(assertCondition(StringUtils.hasContent(association.getName()), "missing a name for an Association on table " + table.getName()))
          {
-            String messageSuffix = " for Association " + association.getName() + " on table " + table.getName();
+            String  messageSuffix   = " for Association " + association.getName() + " on table " + table.getName();
+            boolean recognizedTable = false;
             if(assertCondition(StringUtils.hasContent(association.getAssociatedTableName()), "missing associatedTableName" + messageSuffix))
             {
-               assertCondition(qInstance.getTable(association.getAssociatedTableName()) != null, "unrecognized associatedTableName " + association.getAssociatedTableName() + messageSuffix);
+               if(assertCondition(qInstance.getTable(association.getAssociatedTableName()) != null, "unrecognized associatedTableName " + association.getAssociatedTableName() + messageSuffix))
+               {
+                  recognizedTable = true;
+               }
             }
 
             if(assertCondition(StringUtils.hasContent(association.getJoinName()), "missing joinName" + messageSuffix))
             {
-               assertCondition(qInstance.getJoin(association.getJoinName()) != null, "unrecognized joinName " + association.getJoinName() + messageSuffix);
+               QJoinMetaData join = qInstance.getJoin(association.getJoinName());
+               if(assertCondition(join != null, "unrecognized joinName " + association.getJoinName() + messageSuffix))
+               {
+                  assert join != null; // covered by the assertCondition
+
+                  if(recognizedTable)
+                  {
+                     boolean isLeftToRight = join.getLeftTable().equals(table.getName()) && join.getRightTable().equals(association.getAssociatedTableName());
+                     boolean isRightToLeft = join.getRightTable().equals(table.getName()) && join.getLeftTable().equals(association.getAssociatedTableName());
+                     assertCondition(isLeftToRight || isRightToLeft, "join [" + association.getJoinName() + "] does not connect tables [" + table.getName() + "] and [" + association.getAssociatedTableName() + "]" + messageSuffix);
+                     if(isLeftToRight)
+                     {
+                        assertCondition(join.getType().equals(JoinType.ONE_TO_MANY) || join.getType().equals(JoinType.ONE_TO_ONE), "Join type does not have 'one' on this table's side side (left)" + messageSuffix);
+                     }
+                     else if(isRightToLeft)
+                     {
+                        assertCondition(join.getType().equals(JoinType.MANY_TO_ONE) || join.getType().equals(JoinType.ONE_TO_ONE), "Join type does not have 'one' on this table's side (right)" + messageSuffix);
+                     }
+                  }
+               }
             }
          }
       }
@@ -964,7 +1058,15 @@ public class QInstanceValidator
             @SuppressWarnings("unchecked")
             Class<FieldBehavior<?>> behaviorClass = (Class<FieldBehavior<?>>) fieldBehavior.getClass();
 
-            errors.addAll(fieldBehavior.validateBehaviorConfiguration(table, field));
+            List<String> behaviorErrors = fieldBehavior.validateBehaviorConfiguration(table, field);
+            if(behaviorErrors != null)
+            {
+               String prefixMinusTrailingSpace = prefix.replaceFirst(" *$", "");
+               for(String behaviorError : behaviorErrors)
+               {
+                  errors.add(prefixMinusTrailingSpace + ": " + behaviorClass.getSimpleName() + ": " + behaviorError);
+               }
+            }
 
             if(!fieldBehavior.allowMultipleBehaviorsOfThisType())
             {
@@ -1307,7 +1409,7 @@ public class QInstanceValidator
             //////////////////////////////////////////////////
             // make sure the customizer can be instantiated //
             //////////////////////////////////////////////////
-            Object customizerInstance = getInstanceOfCodeReference(prefix, customizerClass);
+            Object customizerInstance = getInstanceOfCodeReference(prefix, customizerClass, codeReference);
 
             TableCustomizers tableCustomizer = TableCustomizers.forRole(roleName);
             if(tableCustomizer == null)
@@ -1324,7 +1426,7 @@ public class QInstanceValidator
                ////////////////////////////////////////////////////////////////////////
                if(customizerInstance != null && tableCustomizer.getExpectedType() != null)
                {
-                  assertObjectCanBeCasted(prefix, tableCustomizer.getExpectedType(), customizerInstance);
+                  assertObjectCanBeCasted(prefix, customizerInstance, tableCustomizer.getExpectedType());
                }
             }
          }
@@ -1336,18 +1438,31 @@ public class QInstanceValidator
    /*******************************************************************************
     ** Make sure that a given object can be casted to an expected type.
     *******************************************************************************/
-   private <T> T assertObjectCanBeCasted(String errorPrefix, Class<T> expectedType, Object object)
+   private void assertObjectCanBeCasted(String errorPrefix, Object object, Class<?>... anyOfExpectedClasses)
    {
-      T castedObject = null;
-      try
+      for(Class<?> expectedClass : anyOfExpectedClasses)
       {
-         castedObject = expectedType.cast(object);
+         try
+         {
+            expectedClass.cast(object);
+            return;
+         }
+         catch(ClassCastException e)
+         {
+            /////////////////////////////////////
+            // try next type (if there is one) //
+            /////////////////////////////////////
+         }
       }
-      catch(ClassCastException e)
+
+      if(anyOfExpectedClasses.length == 1)
       {
-         errors.add(errorPrefix + "CodeReference is not of the expected type: " + expectedType);
+         errors.add(errorPrefix + "CodeReference is not of the expected type: " + anyOfExpectedClasses[0]);
+      }
+      else
+      {
+         errors.add(errorPrefix + "CodeReference is not any of the expected types: " + Arrays.stream(anyOfExpectedClasses).map(c -> c.getName()).collect(Collectors.joining(", ")));
       }
-      return castedObject;
    }
 
 
@@ -1355,8 +1470,13 @@ public class QInstanceValidator
    /*******************************************************************************
     **
     *******************************************************************************/
-   private Object getInstanceOfCodeReference(String prefix, Class<?> clazz)
+   private Object getInstanceOfCodeReference(String prefix, Class<?> clazz, QCodeReference codeReference)
    {
+      if(codeReference instanceof QCodeReferenceLambda<?> lambdaCodeReference)
+      {
+         return (lambdaCodeReference.getLambda());
+      }
+
       Object instance = null;
       try
       {
@@ -1535,21 +1655,26 @@ public class QInstanceValidator
             Set<String> usedStepNames = new HashSet<>();
             if(assertCondition(CollectionUtils.nullSafeHasContents(process.getStepList()), "At least 1 step must be defined in process " + processName + "."))
             {
-               int index = 0;
+               int index = -1;
                for(QStepMetaData step : process.getStepList())
                {
+                  index++;
                   if(assertCondition(StringUtils.hasContent(step.getName()), "Missing name for a step at index " + index + " in process " + processName))
                   {
                      assertCondition(!usedStepNames.contains(step.getName()), "Duplicate step name [" + step.getName() + "] in process " + processName);
                      usedStepNames.add(step.getName());
                   }
-                  index++;
 
                   ////////////////////////////////////////////
                   // validate instantiation of step classes //
                   ////////////////////////////////////////////
                   if(step instanceof QBackendStepMetaData backendStepMetaData)
                   {
+                     if(assertCondition(backendStepMetaData.getCode() != null, "Missing code for a backend step at index " + index + " in process " + processName))
+                     {
+                        validateSimpleCodeReference("Process " + processName + ", backend step at index " + index + ", code reference: ", backendStepMetaData.getCode(), BackendStep.class);
+                     }
+
                      if(backendStepMetaData.getInputMetaData() != null && CollectionUtils.nullSafeHasContents(backendStepMetaData.getInputMetaData().getFieldList()))
                      {
                         for(QFieldMetaData fieldMetaData : backendStepMetaData.getInputMetaData().getFieldList())
@@ -1584,12 +1709,12 @@ public class QInstanceValidator
 
             for(QFieldMetaData field : process.getInputFields())
             {
-               validateFieldPossibleValueSourceAttributes(qInstance, field, "Process " + processName + ", input field " + field.getName());
+               validateFieldPossibleValueSourceAttributes(qInstance, field, "Process " + processName + ", input field " + field.getName() + " ");
             }
 
             for(QFieldMetaData field : process.getOutputFields())
             {
-               validateFieldPossibleValueSourceAttributes(qInstance, field, "Process " + processName + ", output field " + field.getName());
+               validateFieldPossibleValueSourceAttributes(qInstance, field, "Process " + processName + ", output field " + field.getName() + " ");
             }
 
             if(process.getCancelStep() != null)
@@ -1800,7 +1925,7 @@ public class QInstanceValidator
    /*******************************************************************************
     **
     *******************************************************************************/
-   private void validateQueryFilter(QInstance qInstance, String context, QTableMetaData table, QQueryFilter queryFilter, List<QueryJoin> queryJoins)
+   public void validateQueryFilter(QInstance qInstance, String context, QTableMetaData table, QQueryFilter queryFilter, List<QueryJoin> queryJoins)
    {
       for(QFilterCriteria criterion : CollectionUtils.nonNullList(queryFilter.getCriteria()))
       {
@@ -1844,7 +1969,8 @@ public class QInstanceValidator
       {
          if(fieldName.contains("."))
          {
-            String fieldNameAfterDot = fieldName.substring(fieldName.lastIndexOf(".") + 1);
+            String fieldNameAfterDot  = fieldName.substring(fieldName.lastIndexOf(".") + 1);
+            String tableNameBeforeDot = fieldName.substring(0, fieldName.lastIndexOf("."));
 
             if(CollectionUtils.nullSafeHasContents(queryJoins))
             {
@@ -1868,11 +1994,32 @@ public class QInstanceValidator
             }
             else
             {
-               errors.add("QInstanceValidator does not yet support finding a field that looks like a join field, but isn't associated with a query.");
-               return (true);
-               // todo! for(QJoinMetaData join : CollectionUtils.nonNullMap(qInstance.getJoins()).values())
-               // {
-               // }
+               if(this.joinGraph != null)
+               {
+                  Set<JoinGraph.JoinConnectionList> joinConnections = joinGraph.getJoinConnections(table.getName());
+                  for(JoinGraph.JoinConnectionList joinConnectionList : joinConnections)
+                  {
+                     JoinGraph.JoinConnection joinConnection = joinConnectionList.list().get(joinConnectionList.list().size() - 1);
+                     if(tableNameBeforeDot.equals(joinConnection.joinTable()))
+                     {
+                        QTableMetaData joinTable = qInstance.getTable(tableNameBeforeDot);
+                        if(joinTable.getFields().containsKey(fieldNameAfterDot))
+                        {
+                           /////////////////////////
+                           // mmm, looks valid... //
+                           /////////////////////////
+                           return (true);
+                        }
+                     }
+                  }
+               }
+
+               //////////////////////////////////////////////////////////////////////////////////////
+               // todo - not sure how vulnerable we are to ongoing issues here...                  //
+               // idea:  let a filter (or any object?) be opted out of validation, some version of //
+               // a static map of objects we can check at the top of various validate methods...   //
+               //////////////////////////////////////////////////////////////////////////////////////
+               errors.add("Failed to find field named: " + fieldName);
             }
          }
       }
@@ -1976,6 +2123,11 @@ public class QInstanceValidator
                   }
                }
 
+               if(widget.getValidatorPlugin() != null)
+               {
+                  widget.getValidatorPlugin().validate(widget, qInstance, this);
+               }
+
                runPlugins(QWidgetMetaDataInterface.class, widget, qInstance);
             }
          );
@@ -2075,6 +2227,8 @@ public class QInstanceValidator
             default -> errors.add("Unexpected possibleValueSource type: " + possibleValueSource.getType());
          }
 
+         assertCondition(possibleValueSource.getIdType() != null, "possibleValueSource " + name + " is missing its idType.");
+
          runPlugins(QPossibleValueSource.class, possibleValueSource, qInstance);
       }
    }
@@ -2084,7 +2238,8 @@ public class QInstanceValidator
    /*******************************************************************************
     **
     *******************************************************************************/
-   private void validateSimpleCodeReference(String prefix, QCodeReference codeReference, Class<?> expectedClass)
+   @SafeVarargs
+   private void validateSimpleCodeReference(String prefix, QCodeReference codeReference, Class<?>... anyOfExpectedClasses)
    {
       if(!preAssertionsForCodeReference(codeReference, prefix))
       {
@@ -2105,14 +2260,14 @@ public class QInstanceValidator
             //////////////////////////////////////////////////
             // make sure the customizer can be instantiated //
             //////////////////////////////////////////////////
-            Object classInstance = getInstanceOfCodeReference(prefix, clazz);
+            Object classInstance = getInstanceOfCodeReference(prefix, clazz, codeReference);
 
             ////////////////////////////////////////////////////////////////////////
             // make sure the customizer instance can be cast to the expected type //
             ////////////////////////////////////////////////////////////////////////
             if(classInstance != null)
             {
-               assertObjectCanBeCasted(prefix, expectedClass, classInstance);
+               assertObjectCanBeCasted(prefix, classInstance, anyOfExpectedClasses);
             }
          }
       }
@@ -2128,6 +2283,11 @@ public class QInstanceValidator
       Class<?> clazz = null;
       try
       {
+         if(codeReference instanceof QCodeReferenceLambda<?> lambdaCodeReference)
+         {
+            return (lambdaCodeReference.getLambda().getClass());
+         }
+
          clazz = Class.forName(codeReference.getName());
       }
       catch(ClassNotFoundException e)

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

@@ -72,6 +72,18 @@ public class SecretsManagerUtils
     ** and write them to a .env file (backing up any pre-existing .env files first).
     *******************************************************************************/
    public static void writeEnvFromSecretsWithNamePrefix(String prefix) throws IOException
+   {
+      writeEnvFromSecretsWithNamePrefix(prefix, true);
+   }
+
+
+
+   /*******************************************************************************
+    ** IF secret manager ENV vars are set,
+    ** THEN lookup all secrets starting with the given prefix,
+    ** and write them to a .env file (backing up any pre-existing .env files first).
+    *******************************************************************************/
+   public static void writeEnvFromSecretsWithNamePrefix(String prefix, boolean quoteValues) throws IOException
    {
       Optional<AWSSecretsManager> optionalSecretsManagerClient = getSecretsManagerClient();
       if(optionalSecretsManagerClient.isPresent())
@@ -91,7 +103,9 @@ public class SecretsManagerUtils
                Optional<String> secretValue       = getSecret(prefix, nameWithoutPrefix);
                if(secretValue.isPresent())
                {
-                  String envLine = nameWithoutPrefix + "=" + secretValue.get();
+                  String envLine = quoteValues
+                     ? nameWithoutPrefix + "=\"" + secretValue.get() + "\""
+                     : nameWithoutPrefix + "=" + secretValue.get();
                   fullEnv.append(envLine).append('\n');
                }
             }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/instances/enrichment/plugins/QInstanceEnricherPluginInterface.java

@@ -0,0 +1,40 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2025.  Kingsrook, LLC
+ * 651 N Broad St Ste 205 # 6917 | Middletown DE 19709 | United States
+ * contact@kingsrook.com
+ * https://github.com/Kingsrook/
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.kingsrook.qqq.backend.core.instances.enrichment.plugins;
+
+
+import com.kingsrook.qqq.backend.core.model.metadata.QInstance;
+
+
+/*******************************************************************************
+ ** Interface for additional / optional enrichment to be done on q instance members.
+ ** Some may be provided by QQQ - others can be defined by applications.
+ *******************************************************************************/
+public interface QInstanceEnricherPluginInterface<T>
+{
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   void enrich(T object, QInstance qInstance);
+
+}

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

@@ -0,0 +1,510 @@
+/*
+ * 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.instances.loaders;
+
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.Serializable;
+import java.lang.reflect.Method;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.math.BigDecimal;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.kingsrook.qqq.backend.core.instances.QMetaDataVariableInterpreter;
+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.QMetaDataObject;
+import com.kingsrook.qqq.backend.core.utils.JsonUtils;
+import com.kingsrook.qqq.backend.core.utils.StringUtils;
+import com.kingsrook.qqq.backend.core.utils.ValueUtils;
+import com.kingsrook.qqq.backend.core.utils.YamlUtils;
+import org.apache.commons.io.IOUtils;
+import static com.kingsrook.qqq.backend.core.utils.ValueUtils.getValueAsInteger;
+import static com.kingsrook.qqq.backend.core.utils.ValueUtils.getValueAsString;
+
+
+/*******************************************************************************
+ ** Abstract base class in hierarchy of classes that know how to construct &
+ ** populate QMetaDataObject instances, based on input streams (e.g., from files).
+ *******************************************************************************/
+public abstract class AbstractMetaDataLoader<T extends QMetaDataObject>
+{
+   private static final QLogger LOG = QLogger.getLogger(AbstractMetaDataLoader.class);
+
+   private String fileName;
+
+   private List<LoadingProblem> problems = new ArrayList<>();
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   public T fileToMetaDataObject(QInstance qInstance, InputStream inputStream, String fileName) throws QMetaDataLoaderException
+   {
+      this.fileName = fileName;
+      Map<String, Object> map = fileToMap(inputStream, fileName);
+      LoadingContext loadingContext = new LoadingContext(fileName, "/");
+      return (mapToMetaDataObject(qInstance, map, loadingContext));
+   }
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   public abstract T mapToMetaDataObject(QInstance qInstance, Map<String, Object> map, LoadingContext context) throws QMetaDataLoaderException;
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   protected Map<String, Object> fileToMap(InputStream inputStream, String fileName) throws QMetaDataLoaderException
+   {
+      try
+      {
+         String string = IOUtils.toString(inputStream, StandardCharsets.UTF_8);
+         string = StringUtils.ltrim(string);
+         if(fileName.toLowerCase().endsWith(".json"))
+         {
+            return JsonUtils.toObject(string, new TypeReference<>() {});
+         }
+         else if(fileName.toLowerCase().endsWith(".yaml") || fileName.toLowerCase().endsWith(".yml"))
+         {
+            return YamlUtils.toMap(string);
+         }
+
+         throw (new QMetaDataLoaderException("Unsupported file format (based on file name: " + fileName + ")"));
+      }
+      catch(IOException e)
+      {
+         throw new QMetaDataLoaderException("Error building map from file: " + fileName, e);
+      }
+   }
+
+
+
+   /***************************************************************************
+    *
+    ***************************************************************************/
+   protected void reflectivelyMap(QInstance qInstance, QMetaDataObject targetObject, Map<String, Object> map, LoadingContext context)
+   {
+      Class<? extends QMetaDataObject> targetClass    = targetObject.getClass();
+      Set<String>                      usedFieldNames = new HashSet<>();
+
+      for(Method method : targetClass.getMethods())
+      {
+         try
+         {
+            if(method.getName().startsWith("set") && method.getParameterTypes().length == 1)
+            {
+               String propertyName = StringUtils.lcFirst(method.getName().substring(3));
+
+               if(map.containsKey(propertyName))
+               {
+                  usedFieldNames.add(propertyName);
+                  Class<?> parameterType = method.getParameterTypes()[0];
+                  Object   rawValue      = map.get(propertyName);
+
+                  try
+                  {
+                     Object mappedValue = reflectivelyMapValue(qInstance, method, parameterType, rawValue, context.descendToProperty(propertyName));
+                     method.invoke(targetObject, mappedValue);
+                  }
+                  catch(NoValueException nve)
+                  {
+                     ///////////////////////
+                     // don't call setter //
+                     ///////////////////////
+                     LOG.debug("at " + context + ": No value was mapped for property [" + propertyName + "] on " + targetClass.getSimpleName() + "." + method.getName() + ", raw value: [" + rawValue + "]");
+                  }
+               }
+            }
+         }
+         catch(Exception e)
+         {
+            addProblem(new LoadingProblem(context, "Error reflectively mapping on " + targetClass.getName() + "." + method.getName(), e));
+         }
+      }
+
+      //////////////////////////
+      // mmm, slightly sus... //
+      //////////////////////////
+      map.remove("class");
+      map.remove("version");
+
+      Set<String> unrecognizedKeys = new HashSet<>(map.keySet());
+      unrecognizedKeys.removeAll(usedFieldNames);
+
+      if(!unrecognizedKeys.isEmpty())
+      {
+         addProblem(new LoadingProblem(context, unrecognizedKeys.size() + " Unrecognized " + StringUtils.plural(unrecognizedKeys, "property", "properties") + ": " + unrecognizedKeys));
+      }
+   }
+
+
+
+   /***************************************************************************
+    *
+    ***************************************************************************/
+   public Object reflectivelyMapValue(QInstance qInstance, Method method, Class<?> parameterType, Object rawValue, LoadingContext context) throws Exception
+   {
+      if(rawValue instanceof String s && s.matches("^\\$\\{.+\\..+}"))
+      {
+         rawValue = new QMetaDataVariableInterpreter().interpret(s);
+         LOG.debug("Interpreted raw value [" + s + "] as [" + StringUtils.maskAndTruncate(ValueUtils.getValueAsString(rawValue) + "]"));
+      }
+
+      if(parameterType.equals(String.class))
+      {
+         return (getValueAsString(rawValue));
+      }
+      else if(parameterType.equals(Integer.class))
+      {
+         try
+         {
+            return (getValueAsInteger(rawValue));
+         }
+         catch(Exception e)
+         {
+            addProblem(new LoadingProblem(context, "[" + rawValue + "] is not an Integer value."));
+         }
+      }
+      else if(parameterType.equals(Boolean.class))
+      {
+         if("true".equals(rawValue) || Boolean.TRUE.equals(rawValue))
+         {
+            return (true);
+         }
+         else if("false".equals(rawValue) || Boolean.FALSE.equals(rawValue))
+         {
+            return (false);
+         }
+         else if(rawValue == null)
+         {
+            return (null);
+         }
+         else
+         {
+            addProblem(new LoadingProblem(context, "[" + rawValue + "] is not a boolean value (must be 'true' or 'false')."));
+            return (null);
+         }
+      }
+      else if(parameterType.equals(boolean.class))
+      {
+         if("true".equals(rawValue) || Boolean.TRUE.equals(rawValue))
+         {
+            return (true);
+         }
+         else if("false".equals(rawValue) || Boolean.FALSE.equals(rawValue))
+         {
+            return (false);
+         }
+         else
+         {
+            addProblem(new LoadingProblem(context, rawValue + " is not a boolean value (must be 'true' or 'false')."));
+            throw (new NoValueException());
+         }
+      }
+      else if(parameterType.equals(List.class))
+      {
+         Type     actualTypeArgument = ((ParameterizedType) method.getGenericParameterTypes()[0]).getActualTypeArguments()[0];
+         Class<?> actualTypeClass    = Class.forName(actualTypeArgument.getTypeName());
+
+         if(rawValue instanceof @SuppressWarnings("rawtypes")List valueList)
+         {
+            List<Object> mappedValueList = new ArrayList<>();
+            for(Object o : valueList)
+            {
+               try
+               {
+                  Object mappedValue = reflectivelyMapValue(qInstance, null, actualTypeClass, o, context);
+                  mappedValueList.add(mappedValue);
+               }
+               catch(NoValueException nve)
+               {
+                  // leave off list
+               }
+            }
+            return (mappedValueList);
+         }
+      }
+      else if(parameterType.equals(Set.class))
+      {
+         Type     actualTypeArgument = ((ParameterizedType) method.getGenericParameterTypes()[0]).getActualTypeArguments()[0];
+         Class<?> actualTypeClass    = Class.forName(actualTypeArgument.getTypeName());
+
+         if(rawValue instanceof @SuppressWarnings("rawtypes")List valueList)
+         {
+            Set<Object> mappedValueSet = new LinkedHashSet<>();
+            for(Object o : valueList)
+            {
+               try
+               {
+                  Object mappedValue = reflectivelyMapValue(qInstance, null, actualTypeClass, o, context);
+                  mappedValueSet.add(mappedValue);
+               }
+               catch(NoValueException nve)
+               {
+                  // leave off list
+               }
+            }
+            return (mappedValueSet);
+         }
+      }
+      else if(parameterType.equals(Map.class))
+      {
+         Type keyType = ((ParameterizedType) method.getGenericParameterTypes()[0]).getActualTypeArguments()[0];
+         if(!keyType.equals(String.class))
+         {
+            addProblem(new LoadingProblem(context, "Unsupported key type for " + method + " got [" + keyType + "], expected [String]"));
+            throw new NoValueException();
+         }
+         // todo make sure string
+
+         Type     actualTypeArgument = ((ParameterizedType) method.getGenericParameterTypes()[0]).getActualTypeArguments()[1];
+         Class<?> actualTypeClass    = Class.forName(actualTypeArgument.getTypeName());
+
+         if(rawValue instanceof @SuppressWarnings("rawtypes")Map valueMap)
+         {
+            Map<String, Object> mappedValueMap = new LinkedHashMap<>();
+            for(Object o : valueMap.entrySet())
+            {
+               try
+               {
+                  @SuppressWarnings("unchecked")
+                  Map.Entry<String, Object> entry = (Map.Entry<String, Object>) o;
+                  Object mappedValue = reflectivelyMapValue(qInstance, null, actualTypeClass, entry.getValue(), context);
+                  mappedValueMap.put(entry.getKey(), mappedValue);
+               }
+               catch(NoValueException nve)
+               {
+                  // leave out of map
+               }
+            }
+            return (mappedValueMap);
+         }
+      }
+      else if(parameterType.isEnum())
+      {
+         String value = getValueAsString(rawValue);
+         for(Object enumConstant : parameterType.getEnumConstants())
+         {
+            if(((Enum<?>) enumConstant).name().equals(value))
+            {
+               return (enumConstant);
+            }
+         }
+
+         addProblem(new LoadingProblem(context, "Unrecognized value [" + rawValue + "].  Expected one of: " + Arrays.toString(parameterType.getEnumConstants())));
+      }
+      else if(MetaDataLoaderRegistry.hasLoaderForClass(parameterType))
+      {
+         if(rawValue instanceof @SuppressWarnings("rawtypes")Map valueMap)
+         {
+            Class<? extends AbstractMetaDataLoader<?>> loaderClass = MetaDataLoaderRegistry.getLoaderForClass(parameterType);
+            AbstractMetaDataLoader<?>                  loader      = loaderClass.getConstructor().newInstance();
+            //noinspection unchecked
+            return (loader.mapToMetaDataObject(qInstance, valueMap, context));
+         }
+      }
+      else if(QMetaDataObject.class.isAssignableFrom(parameterType))
+      {
+         if(rawValue instanceof @SuppressWarnings("rawtypes")Map valueMap)
+         {
+            QMetaDataObject childObject = (QMetaDataObject) parameterType.getConstructor().newInstance();
+            //noinspection unchecked
+            reflectivelyMap(qInstance, childObject, valueMap, context);
+            return (childObject);
+         }
+      }
+      else if(parameterType.equals(Serializable.class))
+      {
+         if(rawValue instanceof String
+            || rawValue instanceof Integer
+            || rawValue instanceof BigDecimal
+            || rawValue instanceof Boolean
+         )
+         {
+            return rawValue;
+         }
+      }
+      else
+      {
+         // todo clean up this message/level
+         addProblem(new LoadingProblem(context, "No case for " + parameterType + " (arg to: " + method + ")"));
+      }
+
+      throw new NoValueException();
+   }
+
+   ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+   // unclear if the below is needed.  if so, useful to not re-write, but is hurting test coverage, so zombie until used //
+   ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+   ///***************************************************************************
+   // *
+   // ***************************************************************************/
+   //protected ListOfMapOrMapOfMap getListOfMapOrMapOfMap(Map<String, Object> map, String key)
+   //{
+   //   if(map.containsKey(key))
+   //   {
+   //      if(map.get(key) instanceof List)
+   //      {
+   //         return (new ListOfMapOrMapOfMap((List<Map<String, Object>>) map.get(key)));
+   //      }
+   //      else if(map.get(key) instanceof Map)
+   //      {
+   //         return (new ListOfMapOrMapOfMap((Map<String, Map<String, Object>>) map.get(key)));
+   //      }
+   //      else
+   //      {
+   //         LOG.warn("Expected list or map under key [" + key + "] while processing [" + getClass().getSimpleName() + "] from [" + fileName + "], but found: " + (map.get(key) == null ? "null" : map.get(key).getClass().getSimpleName()));
+   //      }
+   //   }
+
+   //   return (null);
+   //}
+
+   ///***************************************************************************
+   // *
+   // ***************************************************************************/
+   //protected List<Map<String, Object>> getListOfMap(Map<String, Object> map, String key)
+   //{
+   //   if(map.containsKey(key))
+   //   {
+   //      if(map.get(key) instanceof List)
+   //      {
+   //         return (List<Map<String, Object>>) map.get(key);
+   //      }
+   //      else
+   //      {
+   //         LOG.warn("Expected list under key [" + key + "] while processing [" + getClass().getSimpleName() + "] from [" + fileName + "], but found: " + (map.get(key) == null ? "null" : map.get(key).getClass().getSimpleName()));
+   //      }
+   //   }
+
+   //   return (null);
+   //}
+
+   ///***************************************************************************
+   // *
+   // ***************************************************************************/
+   //protected Map<String, Map<String, Object>> getMapOfMap(Map<String, Object> map, String key)
+   //{
+   //   if(map.containsKey(key))
+   //   {
+   //      if(map.get(key) instanceof Map)
+   //      {
+   //         return (Map<String, Map<String, Object>>) map.get(key);
+   //      }
+   //      else
+   //      {
+   //         LOG.warn("Expected map under key [" + key + "] while processing [" + getClass().getSimpleName() + "] from [" + fileName + "], but found: " + (map.get(key) == null ? "null" : map.get(key).getClass().getSimpleName()));
+   //      }
+   //   }
+
+   //   return (null);
+   //}
+
+   ///***************************************************************************
+   // **
+   // ***************************************************************************/
+   //protected record ListOfMapOrMapOfMap(List<Map<String, Object>> listOf, Map<String, Map<String, Object>> mapOf)
+   //{
+   //   /*******************************************************************************
+   //    ** Constructor
+   //    **
+   //    *******************************************************************************/
+   //   public ListOfMapOrMapOfMap(List<Map<String, Object>> listOf)
+   //   {
+   //      this(listOf, null);
+   //   }
+
+   //   /*******************************************************************************
+   //    ** Constructor
+   //    **
+   //    *******************************************************************************/
+   //   public ListOfMapOrMapOfMap(Map<String, Map<String, Object>> mapOf)
+   //   {
+   //      this(null, mapOf);
+   //   }
+   //}
+
+
+
+   /*******************************************************************************
+    ** Getter for fileName
+    **
+    *******************************************************************************/
+   public String getFileName()
+   {
+      return fileName;
+   }
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   private static class NoValueException extends Exception
+   {
+      /*******************************************************************************
+       ** Constructor
+       **
+       *******************************************************************************/
+      public NoValueException()
+      {
+         super("No value");
+      }
+   }
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   public void addProblem(LoadingProblem problem)
+   {
+      problems.add(problem);
+   }
+
+
+
+   /*******************************************************************************
+    ** Getter for problems
+    **
+    *******************************************************************************/
+   public List<LoadingProblem> getProblems()
+   {
+      return (problems);
+   }
+}

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

@@ -0,0 +1,120 @@
+/*
+ * 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.instances.loaders;
+
+
+import java.io.InputStream;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import com.kingsrook.qqq.backend.core.instances.loaders.implementations.GenericMetaDataLoader;
+import com.kingsrook.qqq.backend.core.model.metadata.QInstance;
+import com.kingsrook.qqq.backend.core.model.metadata.QMetaDataObject;
+import com.kingsrook.qqq.backend.core.utils.ClassPathUtils;
+import com.kingsrook.qqq.backend.core.utils.ValueUtils;
+import com.kingsrook.qqq.backend.core.utils.memoization.AnyKey;
+import com.kingsrook.qqq.backend.core.utils.memoization.Memoization;
+
+
+/*******************************************************************************
+ ** Generic implementation of AbstractMetaDataLoader, who "detects" the class
+ ** of meta data object to be created, then defers to an appropriate subclass
+ ** to do the work.
+ *******************************************************************************/
+public class ClassDetectingMetaDataLoader extends AbstractMetaDataLoader<QMetaDataObject>
+{
+   private static final Memoization<AnyKey, List<Class<?>>> memoizedMetaDataObjectClasses = new Memoization<>();
+
+
+   /***************************************************************************
+    *
+    ***************************************************************************/
+   public AbstractMetaDataLoader<?> getLoaderForFile(InputStream inputStream, String fileName) throws QMetaDataLoaderException
+   {
+      Map<String, Object> map = fileToMap(inputStream, fileName);
+      return (getLoaderForMap(map));
+   }
+
+
+
+   /***************************************************************************
+    *
+    ***************************************************************************/
+   public AbstractMetaDataLoader<?> getLoaderForMap(Map<String, Object> map) throws QMetaDataLoaderException
+   {
+      if(map.containsKey("class"))
+      {
+         String classProperty = ValueUtils.getValueAsString(map.get("class"));
+         try
+         {
+            if(MetaDataLoaderRegistry.hasLoaderForSimpleName(classProperty))
+            {
+               Class<? extends AbstractMetaDataLoader<?>> loaderClass = MetaDataLoaderRegistry.getLoaderForSimpleName(classProperty);
+               return (loaderClass.getConstructor().newInstance());
+            }
+            else
+            {
+               Optional<List<Class<?>>> metaDataClasses = memoizedMetaDataObjectClasses.getResult(AnyKey.getInstance(), k -> ClassPathUtils.getClassesContainingNameAndOfType("MetaData", QMetaDataObject.class));
+               if(metaDataClasses.isEmpty())
+               {
+                  throw (new QMetaDataLoaderException("Could not get list of metaDataObjects from class loader"));
+               }
+
+               for(Class<?> c : metaDataClasses.get())
+               {
+                  if(c.getSimpleName().equals(classProperty) && QMetaDataObject.class.isAssignableFrom(c))
+                  {
+                     @SuppressWarnings("unchecked")
+                     Class<? extends QMetaDataObject> metaDataClass = (Class<? extends QMetaDataObject>) c;
+                     return new GenericMetaDataLoader<>(metaDataClass);
+                  }
+               }
+            }
+            throw new QMetaDataLoaderException("Unexpected class [" + classProperty + "] (not a QMetaDataObject; doesn't have a registered MetaDataLoader) specified in " + getFileName());
+         }
+         catch(QMetaDataLoaderException qmdle)
+         {
+            throw (qmdle);
+         }
+         catch(Exception e)
+         {
+            throw new QMetaDataLoaderException("Error handling class [" + classProperty + "] specified in " + getFileName(), e);
+         }
+      }
+      else
+      {
+         throw new QMetaDataLoaderException("Cannot detect meta-data type, because [class] attribute was not specified in file: " + getFileName());
+      }
+   }
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   @Override
+   public QMetaDataObject mapToMetaDataObject(QInstance qInstance, Map<String, Object> map, LoadingContext context) throws QMetaDataLoaderException
+   {
+      AbstractMetaDataLoader<?> loaderForMap = getLoaderForMap(map);
+      return loaderForMap.mapToMetaDataObject(qInstance, map, context);
+   }
+}

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

@@ -0,0 +1,38 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2025.  Kingsrook, LLC
+ * 651 N Broad St Ste 205 # 6917 | Middletown DE 19709 | United States
+ * contact@kingsrook.com
+ * https://github.com/Kingsrook/
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.kingsrook.qqq.backend.core.instances.loaders;
+
+
+/*******************************************************************************
+ ** Record to track where loader objects are - e.g., what file they're on,
+ ** and at what property path within the file (e.g., helps report problems).
+ *******************************************************************************/
+public record LoadingContext(String fileName, String propertyPath)
+{
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   public LoadingContext descendToProperty(String propertyName)
+   {
+      return new LoadingContext(fileName, propertyPath + propertyName + "/");
+   }
+}

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

@@ -0,0 +1,49 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2025.  Kingsrook, LLC
+ * 651 N Broad St Ste 205 # 6917 | Middletown DE 19709 | United States
+ * contact@kingsrook.com
+ * https://github.com/Kingsrook/
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.kingsrook.qqq.backend.core.instances.loaders;
+
+
+/*******************************************************************************
+ ** record that tracks a problem that was encountered when loading files.
+ *******************************************************************************/
+public record LoadingProblem(LoadingContext context, String message, Exception exception) // todo Level if useful
+{
+   /*******************************************************************************
+    ** Constructor
+    **
+    *******************************************************************************/
+   public LoadingProblem(LoadingContext context, String message)
+   {
+      this(context, message, null);
+   }
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   @Override
+   public String toString()
+   {
+      return "at[" + context.fileName() + "][" + context.propertyPath() + "]: " + message;
+   }
+}

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

@@ -0,0 +1,118 @@
+/*
+ * 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.instances.loaders;
+
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import com.kingsrook.qqq.backend.core.exceptions.QException;
+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.QMetaDataObject;
+import com.kingsrook.qqq.backend.core.model.metadata.TopLevelMetaDataInterface;
+import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
+import com.kingsrook.qqq.backend.core.utils.Pair;
+
+
+/*******************************************************************************
+ ** class that loads a directory full of meta data files into meta data objects,
+ ** and then sets all of them in a QInstance.
+ *******************************************************************************/
+public class MetaDataLoaderHelper
+{
+   private static final QLogger LOG = QLogger.getLogger(MetaDataLoaderHelper.class);
+
+
+
+   /***************************************************************************
+    *
+    ***************************************************************************/
+   public static void processAllMetaDataFilesInDirectory(QInstance qInstance, String path) throws QException
+   {
+      List<Pair<File, AbstractMetaDataLoader<?>>> loaders = new ArrayList<>();
+
+      File directory = new File(path);
+      processAllMetaDataFilesInDirectory(loaders, directory);
+
+      // todo - some version of sorting the loaders by type or possibly a sort field within the files (or file names)
+
+      for(Pair<File, AbstractMetaDataLoader<?>> pair : loaders)
+      {
+         File                      file   = pair.getA();
+         AbstractMetaDataLoader<?> loader = pair.getB();
+         try(FileInputStream fileInputStream = new FileInputStream(file))
+         {
+            QMetaDataObject qMetaDataObject = loader.fileToMetaDataObject(qInstance, fileInputStream, file.getName());
+
+            if(CollectionUtils.nullSafeHasContents(loader.getProblems()))
+            {
+               loader.getProblems().forEach(System.out::println);
+            }
+
+            if(qMetaDataObject instanceof TopLevelMetaDataInterface topLevelMetaData)
+            {
+               topLevelMetaData.addSelfToInstance(qInstance);
+            }
+            else
+            {
+               LOG.warn("Received a non-topLevelMetaDataObject from file: " + file.getAbsolutePath());
+            }
+         }
+         catch(Exception e)
+         {
+            LOG.error("Error processing file: " + file.getAbsolutePath(), e);
+         }
+      }
+   }
+
+
+
+   /***************************************************************************
+    *
+    ***************************************************************************/
+   private static void processAllMetaDataFilesInDirectory(List<Pair<File, AbstractMetaDataLoader<?>>> loaders, File directory) throws QException
+   {
+      for(File file : Objects.requireNonNullElse(directory.listFiles(), new File[0]))
+      {
+         if(file.isDirectory())
+         {
+            processAllMetaDataFilesInDirectory(loaders, file);
+         }
+         else
+         {
+            try(FileInputStream fileInputStream = new FileInputStream(file))
+            {
+               AbstractMetaDataLoader<?> loader = new ClassDetectingMetaDataLoader().getLoaderForFile(fileInputStream, file.getName());
+               loaders.add(Pair.of(file, loader));
+            }
+            catch(Exception e)
+            {
+               LOG.error("Error processing file: " + file.getAbsolutePath(), e);
+            }
+         }
+      }
+   }
+
+}

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

@@ -0,0 +1,120 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2025.  Kingsrook, LLC
+ * 651 N Broad St Ste 205 # 6917 | Middletown DE 19709 | United States
+ * contact@kingsrook.com
+ * https://github.com/Kingsrook/
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.kingsrook.qqq.backend.core.instances.loaders;
+
+
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import com.kingsrook.qqq.backend.core.instances.loaders.implementations.QTableMetaDataLoader;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
+import com.kingsrook.qqq.backend.core.utils.ClassPathUtils;
+
+
+/*******************************************************************************
+ **
+ *******************************************************************************/
+public class MetaDataLoaderRegistry
+{
+   private static final QLogger LOG = QLogger.getLogger(AbstractMetaDataLoader.class);
+
+   private static final Map<Class<?>, Class<? extends AbstractMetaDataLoader<?>>> registeredLoaders                   = new HashMap<>();
+   private static final Map<String, Class<? extends AbstractMetaDataLoader<?>>>   registeredLoadersByTargetSimpleName = new HashMap<>();
+
+   static
+   {
+      try
+      {
+         List<Class<?>> classesInPackage = ClassPathUtils.getClassesInPackage(QTableMetaDataLoader.class.getPackageName());
+         for(Class<?> possibleLoaderClass : classesInPackage)
+         {
+            try
+            {
+               Type superClass = possibleLoaderClass.getGenericSuperclass();
+               if(superClass.getTypeName().startsWith(AbstractMetaDataLoader.class.getName() + "<"))
+               {
+                  Type actualTypeArgument = ((ParameterizedType) superClass).getActualTypeArguments()[0];
+                  if(actualTypeArgument instanceof Class)
+                  {
+                     //noinspection unchecked
+                     Class<? extends AbstractMetaDataLoader<?>> loaderClass = (Class<? extends AbstractMetaDataLoader<?>>) possibleLoaderClass;
+
+                     Class<?> metaDataObjectType = Class.forName(actualTypeArgument.getTypeName());
+                     registeredLoaders.put(metaDataObjectType, loaderClass);
+                     registeredLoadersByTargetSimpleName.put(metaDataObjectType.getSimpleName(), loaderClass);
+                  }
+               }
+            }
+            catch(Exception e)
+            {
+               LOG.info("Error on class: " + possibleLoaderClass, e);
+            }
+         }
+
+         System.out.println("Registered loaders: " + registeredLoadersByTargetSimpleName);
+      }
+      catch(Exception e)
+      {
+         LOG.error("Error in static init block for MetaDataLoaderRegistry", e);
+      }
+   }
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   public static boolean hasLoaderForClass(Class<?> metaDataClass)
+   {
+      return registeredLoaders.containsKey(metaDataClass);
+   }
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   public static Class<? extends AbstractMetaDataLoader<?>> getLoaderForClass(Class<?> metaDataClass)
+   {
+      return registeredLoaders.get(metaDataClass);
+   }
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   public static boolean hasLoaderForSimpleName(String targetSimpleName)
+   {
+      return registeredLoadersByTargetSimpleName.containsKey(targetSimpleName);
+   }
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   public static Class<? extends AbstractMetaDataLoader<?>> getLoaderForSimpleName(String targetSimpleName)
+   {
+      return registeredLoadersByTargetSimpleName.get(targetSimpleName);
+   }
+}

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

@@ -0,0 +1,50 @@
+/*
+ * 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.instances.loaders;
+
+
+/*******************************************************************************
+ **
+ *******************************************************************************/
+public class QMetaDataLoaderException extends Exception
+{
+   /*******************************************************************************
+    ** Constructor
+    **
+    *******************************************************************************/
+   public QMetaDataLoaderException(String message)
+   {
+      super(message);
+   }
+
+
+
+   /*******************************************************************************
+    ** Constructor
+    **
+    *******************************************************************************/
+   public QMetaDataLoaderException(String message, Throwable cause)
+   {
+      super(message, cause);
+   }
+
+}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/instances/loaders/implementations/GenericMetaDataLoader.java

@@ -0,0 +1,71 @@
+/*
+ * 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.instances.loaders.implementations;
+
+
+import java.util.Map;
+import com.kingsrook.qqq.backend.core.instances.loaders.AbstractMetaDataLoader;
+import com.kingsrook.qqq.backend.core.instances.loaders.LoadingContext;
+import com.kingsrook.qqq.backend.core.instances.loaders.QMetaDataLoaderException;
+import com.kingsrook.qqq.backend.core.model.metadata.QInstance;
+import com.kingsrook.qqq.backend.core.model.metadata.QMetaDataObject;
+
+
+/*******************************************************************************
+ **
+ *******************************************************************************/
+public class GenericMetaDataLoader<T extends QMetaDataObject> extends AbstractMetaDataLoader<T>
+{
+   private final Class<T> metaDataClass;
+
+
+
+   /*******************************************************************************
+    ** Constructor
+    **
+    *******************************************************************************/
+   public GenericMetaDataLoader(Class<T> metaDataClass)
+   {
+      this.metaDataClass = metaDataClass;
+   }
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   @Override
+   public T mapToMetaDataObject(QInstance qInstance, Map<String, Object> map, LoadingContext context) throws QMetaDataLoaderException
+   {
+      try
+      {
+         T object = metaDataClass.getConstructor().newInstance();
+         reflectivelyMap(qInstance, object, map, context);
+         return (object);
+      }
+      catch(Exception e)
+      {
+         throw (new QMetaDataLoaderException("Error loading metaData object of type " + metaDataClass.getSimpleName(), e));
+      }
+   }
+
+}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/instances/loaders/implementations/QStepDataLoader.java

@@ -0,0 +1,85 @@
+/*
+ * 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.instances.loaders.implementations;
+
+
+import java.util.Map;
+import com.kingsrook.qqq.backend.core.instances.loaders.AbstractMetaDataLoader;
+import com.kingsrook.qqq.backend.core.instances.loaders.LoadingContext;
+import com.kingsrook.qqq.backend.core.instances.loaders.QMetaDataLoaderException;
+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.processes.QBackendStepMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.processes.QFrontendStepMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.processes.QStepMetaData;
+import com.kingsrook.qqq.backend.core.utils.StringUtils;
+import com.kingsrook.qqq.backend.core.utils.ValueUtils;
+
+
+/*******************************************************************************
+ **
+ *******************************************************************************/
+public class QStepDataLoader extends AbstractMetaDataLoader<QStepMetaData>
+{
+   private static final QLogger LOG = QLogger.getLogger(QStepDataLoader.class);
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   @Override
+   public QStepMetaData mapToMetaDataObject(QInstance qInstance, Map<String, Object> map, LoadingContext context) throws QMetaDataLoaderException
+   {
+      String stepType = ValueUtils.getValueAsString(map.get("stepType"));
+
+      if(!StringUtils.hasContent(stepType))
+      {
+         throw (new QMetaDataLoaderException("stepType was not specified for process step"));
+      }
+
+      QStepMetaData step;
+      if("backend".equalsIgnoreCase(stepType))
+      {
+         step = new QBackendStepMetaData();
+         reflectivelyMap(qInstance, step, map, context);
+      }
+      else if("frontend".equalsIgnoreCase(stepType))
+      {
+         step = new QFrontendStepMetaData();
+         reflectivelyMap(qInstance, step, map, context);
+      }
+      // todo - we have custom factory methods for this, so, maybe needs all custom loader?
+      // else if("stateMachine".equalsIgnoreCase(stepType))
+      // {
+      //    step = new QStateMachineStep();
+      //    reflectivelyMap(qInstance, step, map, context);
+      // }
+      else
+      {
+         throw (new QMetaDataLoaderException("Unsupported step stepType: " + stepType));
+      }
+
+      return (step);
+   }
+
+}

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/instances/loaders/implementations/QTableMetaDataLoader.java

@@ -0,0 +1,58 @@
+/*
+ * 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.instances.loaders.implementations;
+
+
+import java.util.Map;
+import com.kingsrook.qqq.backend.core.instances.loaders.AbstractMetaDataLoader;
+import com.kingsrook.qqq.backend.core.instances.loaders.LoadingContext;
+import com.kingsrook.qqq.backend.core.instances.loaders.QMetaDataLoaderException;
+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.QTableMetaData;
+
+
+/*******************************************************************************
+ **
+ *******************************************************************************/
+public class QTableMetaDataLoader extends AbstractMetaDataLoader<QTableMetaData>
+{
+   private static final QLogger LOG = QLogger.getLogger(QTableMetaDataLoader.class);
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   @Override
+   public QTableMetaData mapToMetaDataObject(QInstance qInstance, Map<String, Object> map, LoadingContext context) throws QMetaDataLoaderException
+   {
+      QTableMetaData table = new QTableMetaData();
+
+      reflectivelyMap(qInstance, table, map, context);
+
+      // todo - handle QTableBackendDetails, based on backend's type
+
+      return (table);
+   }
+
+}

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

@@ -326,6 +326,20 @@ public class AuditSingleInput implements Serializable
 
 
 
+   /*******************************************************************************
+    ** Fluent setter for details
+    *******************************************************************************/
+   public AuditSingleInput withDetailMessages(List<String> details)
+   {
+      for(String detail : details)
+      {
+         addDetail(message);
+      }
+      return (this);
+   }
+
+
+
    /*******************************************************************************
     **
     *******************************************************************************/

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

@@ -40,6 +40,8 @@ public class ProcessState implements Serializable
    private Map<String, Serializable> values       = new HashMap<>();
    private List<String>              stepList     = new ArrayList<>();
    private Optional<String>          nextStepName = Optional.empty();
+   private Optional<String>          backStepName = Optional.empty();
+   private boolean                   isStepBack   = false;
 
    private ProcessMetaDataAdjustment processMetaDataAdjustment = null;
 
@@ -122,6 +124,39 @@ public class ProcessState implements Serializable
 
 
 
+   /*******************************************************************************
+    ** Getter for backStepName
+    **
+    *******************************************************************************/
+   public Optional<String> getBackStepName()
+   {
+      return backStepName;
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for backStepName
+    **
+    *******************************************************************************/
+   public void setBackStepName(String backStepName)
+   {
+      this.backStepName = Optional.of(backStepName);
+   }
+
+
+
+   /*******************************************************************************
+    ** clear out the value of backStepName (set the Optional to empty)
+    **
+    *******************************************************************************/
+   public void clearBackStepName()
+   {
+      this.backStepName = Optional.empty();
+   }
+
+
+
    /*******************************************************************************
     ** Getter for stepList
     **
@@ -176,4 +211,35 @@ public class ProcessState implements Serializable
    }
 
 
+
+   /*******************************************************************************
+    ** Getter for isStepBack
+    *******************************************************************************/
+   public boolean getIsStepBack()
+   {
+      return (this.isStepBack);
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for isStepBack
+    *******************************************************************************/
+   public void setIsStepBack(boolean isStepBack)
+   {
+      this.isStepBack = isStepBack;
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for isStepBack
+    *******************************************************************************/
+   public ProcessState withIsStepBack(boolean isStepBack)
+   {
+      this.isStepBack = isStepBack;
+      return (this);
+   }
+
+
 }

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

@@ -53,6 +53,7 @@ public class ProcessSummaryLine implements ProcessSummaryLineInterface
    //////////////////////////////////////////////////////////////////////////
    private ArrayList<Serializable> primaryKeys;
 
+   private ArrayList<String> bulletsOfText;
 
 
    /*******************************************************************************
@@ -497,4 +498,35 @@ public class ProcessSummaryLine implements ProcessSummaryLineInterface
       return (this);
    }
 
+
+   /*******************************************************************************
+    ** Getter for bulletsOfText
+    *******************************************************************************/
+   public ArrayList<String> getBulletsOfText()
+   {
+      return (this.bulletsOfText);
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for bulletsOfText
+    *******************************************************************************/
+   public void setBulletsOfText(ArrayList<String> bulletsOfText)
+   {
+      this.bulletsOfText = bulletsOfText;
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for bulletsOfText
+    *******************************************************************************/
+   public ProcessSummaryLine withBulletsOfText(ArrayList<String> bulletsOfText)
+   {
+      this.bulletsOfText = bulletsOfText;
+      return (this);
+   }
+
+
 }

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

@@ -0,0 +1,162 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2025.  Kingsrook, LLC
+ * 651 N Broad St Ste 205 # 6917 | Middletown DE 19709 | United States
+ * contact@kingsrook.com
+ * https://github.com/Kingsrook/
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.kingsrook.qqq.backend.core.model.actions.processes;
+
+
+import java.io.Serializable;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.exceptions.QRuntimeException;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
+import com.kingsrook.qqq.backend.core.model.data.QRecordEntityField;
+import com.kingsrook.qqq.backend.core.utils.ListingHash;
+import com.kingsrook.qqq.backend.core.utils.ReflectiveBeanLikeClassUtils;
+
+
+/*******************************************************************************
+ ** base-class for bean-like classes to represent the fields of a process.
+ ** similar in spirit to QRecordEntity, but for processes.
+ *******************************************************************************/
+public class QProcessPayload
+{
+   private static final QLogger LOG = QLogger.getLogger(QProcessPayload.class);
+
+   private static final ListingHash<Class<? extends QProcessPayload>, QRecordEntityField> fieldMapping = new ListingHash<>();
+
+
+
+   /*******************************************************************************
+    ** Build an entity of this QRecord type from a QRecord
+    **
+    *******************************************************************************/
+   public static <T extends QProcessPayload> T fromProcessState(Class<T> c, ProcessState processState) throws QException
+   {
+      try
+      {
+         T entity = c.getConstructor().newInstance();
+         entity.populateFromProcessState(processState);
+         return (entity);
+      }
+      catch(Exception e)
+      {
+         throw (new QException("Error building process payload from state.", e));
+      }
+   }
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   protected void populateFromProcessState(ProcessState processState)
+   {
+      try
+      {
+         List<QRecordEntityField> fieldList = getFieldList(this.getClass());
+
+         for(QRecordEntityField qRecordEntityField : fieldList)
+         {
+            Serializable value      = processState.getValues().get(qRecordEntityField.getFieldName());
+            Object       typedValue = qRecordEntityField.convertValueType(value);
+            qRecordEntityField.getSetter().invoke(this, typedValue);
+         }
+      }
+      catch(Exception e)
+      {
+         throw (new QRuntimeException("Error building process payload from process state.", e));
+      }
+   }
+
+
+
+   /*******************************************************************************
+    ** Copy the values from this payload into the given process state.
+    ** ALL fields in the entity will be set in the process state.
+    **
+    *******************************************************************************/
+   public void toProcessState(ProcessState processState) throws QRuntimeException
+   {
+      try
+      {
+         for(QRecordEntityField qRecordEntityField : getFieldList(this.getClass()))
+         {
+            processState.getValues().put(qRecordEntityField.getFieldName(), (Serializable) qRecordEntityField.getGetter().invoke(this));
+         }
+      }
+      catch(Exception e)
+      {
+         throw (new QRuntimeException("Error populating process state from process payload.", e));
+      }
+   }
+
+
+
+   /***************************************************************************
+    *
+    ***************************************************************************/
+   public static Set<Class<?>> allowedFieldTypes()
+   {
+      HashSet<Class<?>> classes = new HashSet<>(ReflectiveBeanLikeClassUtils.defaultAllowedTypes());
+      classes.add(Map.class);
+      classes.add(List.class);
+      return (classes);
+   }
+
+
+
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public static List<QRecordEntityField> getFieldList(Class<? extends QProcessPayload> c)
+   {
+      if(!fieldMapping.containsKey(c))
+      {
+         List<QRecordEntityField> fieldList = new ArrayList<>();
+         for(Method possibleGetter : c.getMethods())
+         {
+            if(ReflectiveBeanLikeClassUtils.isGetter(possibleGetter, false, allowedFieldTypes()))
+            {
+               Optional<Method> setter = ReflectiveBeanLikeClassUtils.getSetterForGetter(c, possibleGetter);
+
+               if(setter.isPresent())
+               {
+                  String fieldName = ReflectiveBeanLikeClassUtils.getFieldNameFromGetter(possibleGetter);
+                  fieldList.add(new QRecordEntityField(fieldName, possibleGetter, setter.get(), possibleGetter.getReturnType(), null));
+               }
+               else
+               {
+                  LOG.debug("Getter method [" + possibleGetter.getName() + "] does not have a corresponding setter.");
+               }
+            }
+         }
+         fieldMapping.put(c, fieldList);
+      }
+      return (fieldMapping.get(c));
+   }
+
+}

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

@@ -25,19 +25,28 @@ package com.kingsrook.qqq.backend.core.model.actions.processes;
 import java.io.Serializable;
 import java.time.Instant;
 import java.time.LocalDate;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.UUID;
 import com.kingsrook.qqq.backend.core.actions.async.AsyncJobCallback;
 import com.kingsrook.qqq.backend.core.actions.async.AsyncJobStatus;
 import com.kingsrook.qqq.backend.core.actions.async.NonPersistedAsyncJobCallback;
 import com.kingsrook.qqq.backend.core.actions.processes.QProcessCallback;
 import com.kingsrook.qqq.backend.core.context.QContext;
+import com.kingsrook.qqq.backend.core.exceptions.QException;
+import com.kingsrook.qqq.backend.core.logging.QLogger;
 import com.kingsrook.qqq.backend.core.model.actions.AbstractActionInput;
 import com.kingsrook.qqq.backend.core.model.data.QRecord;
+import com.kingsrook.qqq.backend.core.model.data.QRecordEntity;
+import com.kingsrook.qqq.backend.core.model.metadata.processes.QProcessMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.processes.QStepMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
+import com.kingsrook.qqq.backend.core.processes.tracing.ProcessTracerInterface;
+import com.kingsrook.qqq.backend.core.processes.tracing.ProcessTracerMessage;
 import com.kingsrook.qqq.backend.core.utils.ValueUtils;
+import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
 
 
 /*******************************************************************************
@@ -46,6 +55,8 @@ import com.kingsrook.qqq.backend.core.utils.ValueUtils;
  *******************************************************************************/
 public class RunBackendStepInput extends AbstractActionInput
 {
+   private static final QLogger LOG = QLogger.getLogger(RunBackendStepInput.class);
+
    private ProcessState                         processState;
    private String                               processName;
    private String                               tableName;
@@ -55,12 +66,13 @@ public class RunBackendStepInput extends AbstractActionInput
    private RunProcessInput.FrontendStepBehavior frontendStepBehavior;
    private Instant                              basepullLastRunTime;
 
+   private ProcessTracerInterface processTracer;
+
    ////////////////////////////////////////////////////////////////////////////
    // note - new fields should generally be added in method: cloneFieldsInto //
    ////////////////////////////////////////////////////////////////////////////
 
 
-
    /*******************************************************************************
     **
     *******************************************************************************/
@@ -96,6 +108,7 @@ public class RunBackendStepInput extends AbstractActionInput
       target.setAsyncJobCallback(getAsyncJobCallback());
       target.setFrontendStepBehavior(getFrontendStepBehavior());
       target.setValues(getValues());
+      target.setProcessTracer(getProcessTracer().orElse(null));
    }
 
 
@@ -238,6 +251,26 @@ public class RunBackendStepInput extends AbstractActionInput
 
 
 
+   /*******************************************************************************
+    ** Getter for records converted to entities of a given type.
+    **
+    *******************************************************************************/
+   public <E extends QRecordEntity> List<E> getRecordsAsEntities(Class<E> entityClass) throws QException
+   {
+      List<E> rs = new ArrayList<>();
+
+      ///////////////////////////////////////////////////////////////////////////////////
+      // note - important to call getRecords here, which is overwritten in subclasses! //
+      ///////////////////////////////////////////////////////////////////////////////////
+      for(QRecord record : getRecords())
+      {
+         rs.add(QRecordEntity.fromQRecord(entityClass, record));
+      }
+      return (rs);
+   }
+
+
+
    /*******************************************************************************
     ** Setter for records
     **
@@ -419,6 +452,17 @@ public class RunBackendStepInput extends AbstractActionInput
 
 
 
+   /*******************************************************************************
+    ** Accessor for processState's isStepBack attribute
+    **
+    *******************************************************************************/
+   public boolean getIsStepBack()
+   {
+      return processState.getIsStepBack();
+   }
+
+
+
    /*******************************************************************************
     ** Accessor for processState - protected, because we generally want to access
     ** its members through wrapper methods, we think
@@ -524,4 +568,75 @@ public class RunBackendStepInput extends AbstractActionInput
       return (this);
    }
 
+
+
+   /*******************************************************************************
+    ** Setter for processTracer
+    *******************************************************************************/
+   public void setProcessTracer(ProcessTracerInterface processTracer)
+   {
+      this.processTracer = processTracer;
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for processTracer
+    *******************************************************************************/
+   public RunBackendStepInput withProcessTracer(ProcessTracerInterface processTracer)
+   {
+      this.processTracer = processTracer;
+      return (this);
+   }
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   public Optional<ProcessTracerInterface> getProcessTracer()
+   {
+      return Optional.ofNullable(processTracer);
+   }
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   public void traceMessage(ProcessTracerMessage message)
+   {
+      if(processTracer != null && message != null)
+      {
+         try
+         {
+            processTracer.handleMessage(this, message);
+         }
+         catch(Exception e)
+         {
+            LOG.warn("Error tracing message", e, logPair("message", message));
+         }
+      }
+   }
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   public QProcessMetaData getProcess()
+   {
+      return (QContext.getQInstance().getProcess(getProcessName()));
+   }
+
+
+
+   /***************************************************************************
+    ** return a QProcessPayload subclass instance, with values populated from
+    ** the current process state.
+    ***************************************************************************/
+   public <T extends QProcessPayload> T getProcessPayload(Class<T> payloadClass) throws QException
+   {
+      return QProcessPayload.fromProcessState(payloadClass, getProcessState());
+   }
 }

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

@@ -33,6 +33,7 @@ import com.kingsrook.qqq.backend.core.model.actions.AbstractActionOutput;
 import com.kingsrook.qqq.backend.core.model.actions.audits.AuditInput;
 import com.kingsrook.qqq.backend.core.model.actions.audits.AuditSingleInput;
 import com.kingsrook.qqq.backend.core.model.data.QRecord;
+import com.kingsrook.qqq.backend.core.model.data.QRecordEntity;
 import com.kingsrook.qqq.backend.core.model.metadata.processes.QFrontendStepMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.processes.QProcessMetaData;
 import com.kingsrook.qqq.backend.core.utils.ValueUtils;
@@ -258,7 +259,7 @@ public class RunBackendStepOutput extends AbstractActionOutput implements Serial
 
 
    /*******************************************************************************
-    **
+    ** add a record to the step output, e.g., for going through to the next step.
     *******************************************************************************/
    public void addRecord(QRecord record)
    {
@@ -271,6 +272,16 @@ public class RunBackendStepOutput extends AbstractActionOutput implements Serial
 
 
 
+   /***************************************************************************
+    ** add a RecordEntity to the step output, e.g., for going through to the next step.
+    ***************************************************************************/
+   public void addRecordEntity(QRecordEntity recordEntity)
+   {
+      addRecord(recordEntity.toQRecord());
+   }
+
+
+
    /*******************************************************************************
     ** Getter for auditInputList
     *******************************************************************************/
@@ -434,4 +445,14 @@ public class RunBackendStepOutput extends AbstractActionOutput implements Serial
       this.processState.setProcessMetaDataAdjustment(processMetaDataAdjustment);
    }
 
+
+
+   /***************************************************************************
+    ** Update the process state with values from the input processPayload
+    ** subclass instance.
+    ***************************************************************************/
+   public void setProcessPayload(QProcessPayload processPayload)
+   {
+      processPayload.toProcessState(getProcessState());
+   }
 }

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

@@ -49,6 +49,7 @@ public class RunProcessInput extends AbstractActionInput
    private ProcessState         processState;
    private FrontendStepBehavior frontendStepBehavior = FrontendStepBehavior.BREAK;
    private String               startAfterStep;
+   private String               startAtStep;
    private String               processUUID;
    private AsyncJobCallback     asyncJobCallback;
 
@@ -451,4 +452,35 @@ public class RunProcessInput extends AbstractActionInput
    {
       return asyncJobCallback;
    }
+
+   /*******************************************************************************
+    ** Getter for startAtStep
+    *******************************************************************************/
+   public String getStartAtStep()
+   {
+      return (this.startAtStep);
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for startAtStep
+    *******************************************************************************/
+   public void setStartAtStep(String startAtStep)
+   {
+      this.startAtStep = startAtStep;
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for startAtStep
+    *******************************************************************************/
+   public RunProcessInput withStartAtStep(String startAtStep)
+   {
+      this.startAtStep = startAtStep;
+      return (this);
+   }
+
+
 }

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

@@ -28,6 +28,7 @@ import java.util.Map;
 import java.util.function.Supplier;
 import com.kingsrook.qqq.backend.core.actions.reporting.ExportStreamerInterface;
 import com.kingsrook.qqq.backend.core.model.actions.AbstractTableActionInput;
+import com.kingsrook.qqq.backend.core.model.metadata.code.QCodeReference;
 import com.kingsrook.qqq.backend.core.model.metadata.reporting.QReportMetaData;
 
 
@@ -44,6 +45,7 @@ public class ReportInput extends AbstractTableActionInput
    private ReportDestination reportDestination;
 
    private Supplier<? extends ExportStreamerInterface> overrideExportStreamerSupplier;
+   private QCodeReference                              exportStyleCustomizer;
 
 
 
@@ -208,4 +210,35 @@ public class ReportInput extends AbstractTableActionInput
       return (this);
    }
 
+
+
+   /*******************************************************************************
+    ** Getter for exportStyleCustomizer
+    *******************************************************************************/
+   public QCodeReference getExportStyleCustomizer()
+   {
+      return (this.exportStyleCustomizer);
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for exportStyleCustomizer
+    *******************************************************************************/
+   public void setExportStyleCustomizer(QCodeReference exportStyleCustomizer)
+   {
+      this.exportStyleCustomizer = exportStyleCustomizer;
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for exportStyleCustomizer
+    *******************************************************************************/
+   public ReportInput withExportStyleCustomizer(QCodeReference exportStyleCustomizer)
+   {
+      this.exportStyleCustomizer = exportStyleCustomizer;
+      return (this);
+   }
+
 }

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

@@ -0,0 +1,31 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2025.  Kingsrook, LLC
+ * 651 N Broad St Ste 205 # 6917 | Middletown DE 19709 | United States
+ * contact@kingsrook.com
+ * https://github.com/Kingsrook/
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.kingsrook.qqq.backend.core.model.actions.tables.query;
+
+
+/*******************************************************************************
+ **
+ *******************************************************************************/
+public enum CriteriaOption implements CriteriaOptionInterface
+{
+   CASE_INSENSITIVE;
+}

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

@@ -0,0 +1,30 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2025.  Kingsrook, LLC
+ * 651 N Broad St Ste 205 # 6917 | Middletown DE 19709 | United States
+ * contact@kingsrook.com
+ * https://github.com/Kingsrook/
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.kingsrook.qqq.backend.core.model.actions.tables.query;
+
+
+/*******************************************************************************
+ **
+ *******************************************************************************/
+public interface CriteriaOptionInterface
+{
+}

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

@@ -26,11 +26,14 @@ import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Objects;
+import java.util.Set;
 import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
 import com.kingsrook.qqq.backend.core.logging.QLogger;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.serialization.QFilterCriteriaDeserializer;
+import com.kingsrook.qqq.backend.core.model.metadata.QMetaDataObject;
 import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
 import com.kingsrook.qqq.backend.core.utils.StringUtils;
 
@@ -40,11 +43,11 @@ import com.kingsrook.qqq.backend.core.utils.StringUtils;
  *
  *******************************************************************************/
 @JsonDeserialize(using = QFilterCriteriaDeserializer.class)
-public class QFilterCriteria implements Serializable, Cloneable
+public class QFilterCriteria implements Serializable, Cloneable, QMetaDataObject
 {
    private static final QLogger LOG = QLogger.getLogger(QFilterCriteria.class);
 
-   private String fieldName;
+   private String             fieldName;
    private QCriteriaOperator  operator;
    private List<Serializable> values;
 
@@ -53,6 +56,8 @@ public class QFilterCriteria implements Serializable, Cloneable
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    private String otherFieldName;
 
+   private Set<CriteriaOptionInterface> options = null;
+
 
 
    /*******************************************************************************
@@ -69,6 +74,13 @@ public class QFilterCriteria implements Serializable, Cloneable
             clone.values = new ArrayList<>();
             clone.values.addAll(values);
          }
+
+         if(options != null)
+         {
+            clone.options = new HashSet<>();
+            clone.options.addAll(options);
+         }
+
          return clone;
       }
       catch(CloneNotSupportedException e)
@@ -385,4 +397,78 @@ public class QFilterCriteria implements Serializable, Cloneable
       return Objects.hash(fieldName, operator, values, otherFieldName);
    }
 
+
+
+   /*******************************************************************************
+    ** Getter for options
+    *******************************************************************************/
+   public Set<CriteriaOptionInterface> getOptions()
+   {
+      return (this.options);
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for options
+    *******************************************************************************/
+   public void setOptions(Set<CriteriaOptionInterface> options)
+   {
+      this.options = options;
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for options
+    *******************************************************************************/
+   public QFilterCriteria withOptions(Set<CriteriaOptionInterface> options)
+   {
+      this.options = options;
+      return (this);
+   }
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   public QFilterCriteria withOption(CriteriaOptionInterface option)
+   {
+      if(options == null)
+      {
+         options = new HashSet<>();
+      }
+      options.add(option);
+      return (this);
+   }
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   public QFilterCriteria withoutOption(CriteriaOptionInterface option)
+   {
+      if(options != null)
+      {
+         options.remove(option);
+      }
+      return (this);
+   }
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   public boolean hasOption(CriteriaOptionInterface option)
+   {
+      if(options == null)
+      {
+         return (false);
+      }
+
+      return (options.contains(option));
+   }
+
 }

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

@@ -23,13 +23,14 @@ package com.kingsrook.qqq.backend.core.model.actions.tables.query;
 
 
 import java.io.Serializable;
+import com.kingsrook.qqq.backend.core.model.metadata.QMetaDataObject;
 
 
 /*******************************************************************************
  ** Bean representing an element of a query order-by clause.
  **
  *******************************************************************************/
-public class QFilterOrderBy implements Serializable, Cloneable
+public class QFilterOrderBy implements Serializable, Cloneable, QMetaDataObject
 {
    private String  fieldName;
    private boolean isAscending = true;

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

@@ -36,6 +36,7 @@ import com.kingsrook.qqq.backend.core.instances.QMetaDataVariableInterpreter;
 import com.kingsrook.qqq.backend.core.logging.QLogger;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.expressions.AbstractFilterExpression;
 import com.kingsrook.qqq.backend.core.model.actions.tables.query.expressions.FilterVariableExpression;
+import com.kingsrook.qqq.backend.core.model.metadata.QMetaDataObject;
 import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
 import com.kingsrook.qqq.backend.core.utils.StringUtils;
 import com.kingsrook.qqq.backend.core.utils.ValueUtils;
@@ -45,7 +46,7 @@ import com.kingsrook.qqq.backend.core.utils.ValueUtils;
  * Full "filter" for a query - a list of criteria and order-bys
  *
  *******************************************************************************/
-public class QQueryFilter implements Serializable, Cloneable
+public class QQueryFilter implements Serializable, Cloneable, QMetaDataObject
 {
    private static final QLogger LOG = QLogger.getLogger(QQueryFilter.class);
 
@@ -55,6 +56,16 @@ public class QQueryFilter implements Serializable, Cloneable
    private BooleanOperator    booleanOperator = BooleanOperator.AND;
    private List<QQueryFilter> subFilters      = new ArrayList<>();
 
+   //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+   // initial intent here was - put, e.g., UNION between multiple SELECT (with the individual selects being defined in subFilters) //
+   // but, actually SQL would let us do, e.g., SELECT UNION SELECT INTERSECT SELECT                                                //
+   // so - we could see a future implementation where we:                                                                          //
+   // - used the top-level subFilterSetOperator to indicate hat we are doing a multi-query set-operation query.                    //
+   // - looked within the subFilter, to see if it specified a subFilterSetOperator - and use that operator before that query       //
+   // but - in v0, just using the one at the top-level works                                                                       //
+   //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+   private SubFilterSetOperator subFilterSetOperator = null;
+
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
    // skip & limit are meant to only apply to QueryAction (at least at the initial time they are added here) //
    // e.g., they are ignored in CountAction, AggregateAction, etc, where their meanings may be less obvious  //
@@ -75,6 +86,19 @@ public class QQueryFilter implements Serializable, Cloneable
 
 
 
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   public enum SubFilterSetOperator
+   {
+      UNION,
+      UNION_ALL,
+      INTERSECT,
+      EXCEPT
+   }
+
+
+
    /*******************************************************************************
     ** Constructor
     **
@@ -799,4 +823,51 @@ public class QQueryFilter implements Serializable, Cloneable
       }
    }
 
+
+   /*******************************************************************************
+    ** Getter for subFilterSetOperator
+    *******************************************************************************/
+   public SubFilterSetOperator getSubFilterSetOperator()
+   {
+      return (this.subFilterSetOperator);
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for subFilterSetOperator
+    *******************************************************************************/
+   public void setSubFilterSetOperator(SubFilterSetOperator subFilterSetOperator)
+   {
+      this.subFilterSetOperator = subFilterSetOperator;
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for subFilterSetOperator
+    *******************************************************************************/
+   public QQueryFilter withSubFilterSetOperator(SubFilterSetOperator subFilterSetOperator)
+   {
+      this.subFilterSetOperator = subFilterSetOperator;
+      return (this);
+   }
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   public void applyCriteriaOptionToAllCriteria(CriteriaOptionInterface criteriaOption)
+   {
+      for(QFilterCriteria criteria : CollectionUtils.nonNullList(this.criteria))
+      {
+         criteria.withOption(criteriaOption);
+      }
+
+      for(QQueryFilter subFilter : CollectionUtils.nonNullList(subFilters))
+      {
+         subFilter.applyCriteriaOptionToAllCriteria(criteriaOption);
+      }
+   }
+
 }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/actions/tables/storage/StorageInput.java

@@ -22,13 +22,14 @@
 package com.kingsrook.qqq.backend.core.model.actions.tables.storage;
 
 
+import java.io.Serializable;
 import com.kingsrook.qqq.backend.core.model.actions.AbstractTableActionInput;
 
 
 /*******************************************************************************
  ** Input for Storage actions.
  *******************************************************************************/
-public class StorageInput extends AbstractTableActionInput
+public class StorageInput extends AbstractTableActionInput implements Serializable
 {
    private String reference;
    private String contentType;

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

@@ -38,9 +38,10 @@ public class SearchPossibleValueSourceInput extends AbstractActionInput implemen
    private QQueryFilter       defaultQueryFilter;
    private String             searchTerm;
    private List<Serializable> idList;
+   private List<String>       labelList;
 
    private Integer skip  = 0;
-   private Integer limit = 100;
+   private Integer limit = 250;
 
 
 
@@ -281,4 +282,35 @@ public class SearchPossibleValueSourceInput extends AbstractActionInput implemen
       this.limit = limit;
       return (this);
    }
+
+
+   /*******************************************************************************
+    ** Getter for labelList
+    *******************************************************************************/
+   public List<String> getLabelList()
+   {
+      return (this.labelList);
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for labelList
+    *******************************************************************************/
+   public void setLabelList(List<String> labelList)
+   {
+      this.labelList = labelList;
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for labelList
+    *******************************************************************************/
+   public SearchPossibleValueSourceInput withLabelList(List<String> labelList)
+   {
+      this.labelList = labelList;
+      return (this);
+   }
+
 }

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

@@ -35,6 +35,7 @@ public class SearchPossibleValueSourceOutput extends AbstractActionOutput
 {
    private List<QPossibleValue<?>> results = new ArrayList<>();
 
+   private String warning;
 
 
    /*******************************************************************************
@@ -88,4 +89,35 @@ public class SearchPossibleValueSourceOutput extends AbstractActionOutput
       return (this);
    }
 
+
+   /*******************************************************************************
+    ** Getter for warning
+    *******************************************************************************/
+   public String getWarning()
+   {
+      return (this.warning);
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for warning
+    *******************************************************************************/
+   public void setWarning(String warning)
+   {
+      this.warning = warning;
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for warning
+    *******************************************************************************/
+   public SearchPossibleValueSourceOutput withWarning(String warning)
+   {
+      this.warning = warning;
+      return (this);
+   }
+
+
 }

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

@@ -51,6 +51,7 @@ public class ChildRecordListData extends QWidgetData
    private boolean                   canAddChildRecord = false;
    private Map<String, Serializable> defaultValuesForNewChildRecords;
    private Set<String>               disabledFieldsForNewChildRecords;
+   private Map<String, String>       defaultValuesForNewChildRecordsFromParentFields;
 
 
 
@@ -523,6 +524,37 @@ public class ChildRecordListData extends QWidgetData
       return (this);
    }
 
+
+
+   /*******************************************************************************
+    ** Getter for defaultValuesForNewChildRecordsFromParentFields
+    *******************************************************************************/
+   public Map<String, String> getDefaultValuesForNewChildRecordsFromParentFields()
+   {
+      return (this.defaultValuesForNewChildRecordsFromParentFields);
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for defaultValuesForNewChildRecordsFromParentFields
+    *******************************************************************************/
+   public void setDefaultValuesForNewChildRecordsFromParentFields(Map<String, String> defaultValuesForNewChildRecordsFromParentFields)
+   {
+      this.defaultValuesForNewChildRecordsFromParentFields = defaultValuesForNewChildRecordsFromParentFields;
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for defaultValuesForNewChildRecordsFromParentFields
+    *******************************************************************************/
+   public ChildRecordListData withDefaultValuesForNewChildRecordsFromParentFields(Map<String, String> defaultValuesForNewChildRecordsFromParentFields)
+   {
+      this.defaultValuesForNewChildRecordsFromParentFields = defaultValuesForNewChildRecordsFromParentFields;
+      return (this);
+   }
+
 }
 
 

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

@@ -34,8 +34,12 @@ public class FilterAndColumnsSetupData extends QWidgetData
    private String       tableName;
    private Boolean      allowVariables = false;
    private Boolean      hideColumns    = false;
+   private Boolean      hidePreview    = false;
    private List<String> filterDefaultFieldNames;
 
+   private String filterFieldName = "queryFilterJson";
+   private String columnFieldName = "columnsJson";
+
 
 
    /*******************************************************************************
@@ -193,4 +197,97 @@ public class FilterAndColumnsSetupData extends QWidgetData
       return (this);
    }
 
+
+
+   /*******************************************************************************
+    ** Getter for hidePreview
+    *******************************************************************************/
+   public Boolean getHidePreview()
+   {
+      return (this.hidePreview);
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for hidePreview
+    *******************************************************************************/
+   public void setHidePreview(Boolean hidePreview)
+   {
+      this.hidePreview = hidePreview;
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for hidePreview
+    *******************************************************************************/
+   public FilterAndColumnsSetupData withHidePreview(Boolean hidePreview)
+   {
+      this.hidePreview = hidePreview;
+      return (this);
+   }
+
+
+
+   /*******************************************************************************
+    ** Getter for filterFieldName
+    *******************************************************************************/
+   public String getFilterFieldName()
+   {
+      return (this.filterFieldName);
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for filterFieldName
+    *******************************************************************************/
+   public void setFilterFieldName(String filterFieldName)
+   {
+      this.filterFieldName = filterFieldName;
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for filterFieldName
+    *******************************************************************************/
+   public FilterAndColumnsSetupData withFilterFieldName(String filterFieldName)
+   {
+      this.filterFieldName = filterFieldName;
+      return (this);
+   }
+
+
+
+   /*******************************************************************************
+    ** Getter for columnFieldName
+    *******************************************************************************/
+   public String getColumnFieldName()
+   {
+      return (this.columnFieldName);
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for columnFieldName
+    *******************************************************************************/
+   public void setColumnFieldName(String columnFieldName)
+   {
+      this.columnFieldName = columnFieldName;
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for columnFieldName
+    *******************************************************************************/
+   public FilterAndColumnsSetupData withColumnFieldName(String columnFieldName)
+   {
+      this.columnFieldName = columnFieldName;
+      return (this);
+   }
+
 }

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

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

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

@@ -89,6 +89,11 @@ public @interface QField
     *******************************************************************************/
    int maxLength() default Integer.MAX_VALUE;
 
+   /*******************************************************************************
+    **
+    *******************************************************************************/
+   int gridColumns() default -1;
+
    /*******************************************************************************
     **
     *******************************************************************************/

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

@@ -154,7 +154,7 @@ public class QRecord implements Serializable
          return (null);
       }
 
-      Map<String, V> clone = new LinkedHashMap<>();
+      Map<String, V> clone = new LinkedHashMap<>(map.size());
       for(Map.Entry<String, V> entry : map.entrySet())
       {
          Serializable value = entry.getValue();
@@ -246,6 +246,24 @@ public class QRecord implements Serializable
    }
 
 
+   /***************************************************************************
+    ** copy all values from 'joinedRecord' into this record's values map,
+    ** prefixing field names with joinTableNam + "."
+    ***************************************************************************/
+   public void addJoinedRecordValues(String joinTableName, QRecord joinedRecord)
+   {
+      if(joinedRecord == null)
+      {
+         return;
+      }
+
+      for(Map.Entry<String, Serializable> entry : joinedRecord.getValues().entrySet())
+      {
+         setValue(joinTableName + "." + entry.getKey(), entry.getValue());
+      }
+   }
+
+
 
    /*******************************************************************************
     **
@@ -450,7 +468,7 @@ public class QRecord implements Serializable
     *******************************************************************************/
    public String getValueString(String fieldName)
    {
-      return (ValueUtils.getValueAsString(values.get(fieldName)));
+      return (ValueUtils.getValueAsString(getValue(fieldName)));
    }
 
 
@@ -461,7 +479,7 @@ public class QRecord implements Serializable
     *******************************************************************************/
    public Integer getValueInteger(String fieldName)
    {
-      return (ValueUtils.getValueAsInteger(values.get(fieldName)));
+      return (ValueUtils.getValueAsInteger(getValue(fieldName)));
    }
 
 
@@ -472,7 +490,7 @@ public class QRecord implements Serializable
     *******************************************************************************/
    public Long getValueLong(String fieldName)
    {
-      return (ValueUtils.getValueAsLong(values.get(fieldName)));
+      return (ValueUtils.getValueAsLong(getValue(fieldName)));
    }
 
 
@@ -482,7 +500,7 @@ public class QRecord implements Serializable
     *******************************************************************************/
    public BigDecimal getValueBigDecimal(String fieldName)
    {
-      return (ValueUtils.getValueAsBigDecimal(values.get(fieldName)));
+      return (ValueUtils.getValueAsBigDecimal(getValue(fieldName)));
    }
 
 
@@ -492,7 +510,7 @@ public class QRecord implements Serializable
     *******************************************************************************/
    public Boolean getValueBoolean(String fieldName)
    {
-      return (ValueUtils.getValueAsBoolean(values.get(fieldName)));
+      return (ValueUtils.getValueAsBoolean(getValue(fieldName)));
    }
 
 
@@ -502,7 +520,7 @@ public class QRecord implements Serializable
     *******************************************************************************/
    public LocalTime getValueLocalTime(String fieldName)
    {
-      return (ValueUtils.getValueAsLocalTime(values.get(fieldName)));
+      return (ValueUtils.getValueAsLocalTime(getValue(fieldName)));
    }
 
 
@@ -512,7 +530,7 @@ public class QRecord implements Serializable
     *******************************************************************************/
    public LocalDate getValueLocalDate(String fieldName)
    {
-      return (ValueUtils.getValueAsLocalDate(values.get(fieldName)));
+      return (ValueUtils.getValueAsLocalDate(getValue(fieldName)));
    }
 
 
@@ -522,7 +540,7 @@ public class QRecord implements Serializable
     *******************************************************************************/
    public byte[] getValueByteArray(String fieldName)
    {
-      return (ValueUtils.getValueAsByteArray(values.get(fieldName)));
+      return (ValueUtils.getValueAsByteArray(getValue(fieldName)));
    }
 
 
@@ -532,7 +550,7 @@ public class QRecord implements Serializable
     *******************************************************************************/
    public Instant getValueInstant(String fieldName)
    {
-      return (ValueUtils.getValueAsInstant(values.get(fieldName)));
+      return (ValueUtils.getValueAsInstant(getValue(fieldName)));
    }
 
 

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

@@ -41,11 +41,15 @@ import java.util.Locale;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
+import java.util.function.Function;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
 import com.kingsrook.qqq.backend.core.exceptions.QRuntimeException;
 import com.kingsrook.qqq.backend.core.logging.QLogger;
+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.ListingHash;
+import com.kingsrook.qqq.backend.core.utils.ObjectUtils;
+import com.kingsrook.qqq.backend.core.utils.ReflectiveBeanLikeClassUtils;
 import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
 
 
@@ -61,6 +65,11 @@ public abstract class QRecordEntity
 
    private Map<String, Serializable> originalRecordValues;
 
+   ////////////////////////////////////////////////////////////////////////////////
+   // map of entity class names to QTableMetaData objects that they helped build //
+   ////////////////////////////////////////////////////////////////////////////////
+   private static Map<String, QTableMetaData> tableReferences = new HashMap<>();
+
 
 
    /*******************************************************************************
@@ -95,6 +104,19 @@ public abstract class QRecordEntity
 
 
 
+   /***************************************************************************
+    ** register a mapping between an entity class and a table that it is associated with.
+    ***************************************************************************/
+   public static void registerTable(Class<? extends QRecordEntity> entityClass, QTableMetaData table)
+   {
+      if(entityClass != null && table != null)
+      {
+         tableReferences.put(entityClass.getName(), table);
+      }
+   }
+
+
+
    /*******************************************************************************
     ** Build an entity of this QRecord type from a QRecord
     **
@@ -176,7 +198,10 @@ public abstract class QRecordEntity
 
 
    /*******************************************************************************
-    ** Convert this entity to a QRecord.
+    ** Convert this entity to a QRecord.  ALL fields in the entity will be set
+    ** in the QRecord.  Note that, if you're using this for an input to the UpdateAction,
+    ** that this could cause values to be set to null, e.g., if you constructed
+    ** a entity from scratch, and didn't set all values in it!!
     **
     *******************************************************************************/
    public QRecord toQRecord() throws QRuntimeException
@@ -190,25 +215,7 @@ public abstract class QRecordEntity
             qRecord.setValue(qRecordEntityField.getFieldName(), (Serializable) qRecordEntityField.getGetter().invoke(this));
          }
 
-         for(QRecordEntityAssociation qRecordEntityAssociation : getAssociationList(this.getClass()))
-         {
-            @SuppressWarnings("unchecked")
-            List<? extends QRecordEntity> associatedEntities = (List<? extends QRecordEntity>) qRecordEntityAssociation.getGetter().invoke(this);
-            String                        associationName    = qRecordEntityAssociation.getAssociationAnnotation().name();
-
-            if(associatedEntities != null)
-            {
-               /////////////////////////////////////////////////////////////////////////////////
-               // do this so an empty list in the entity becomes an empty list in the QRecord //
-               /////////////////////////////////////////////////////////////////////////////////
-               qRecord.withAssociatedRecords(associationName, new ArrayList<>());
-            }
-
-            for(QRecordEntity associatedEntity : CollectionUtils.nonNullList(associatedEntities))
-            {
-               qRecord.withAssociatedRecord(associationName, associatedEntity.toQRecord());
-            }
-         }
+         toQRecordProcessAssociations(qRecord, (entity) -> entity.toQRecord());
 
          return (qRecord);
       }
@@ -220,15 +227,65 @@ public abstract class QRecordEntity
 
 
 
+   /***************************************************************************
+    *
+    ***************************************************************************/
+   private void toQRecordProcessAssociations(QRecord outputRecord, Function<QRecordEntity, QRecord> toRecordFunction) throws Exception
+   {
+      for(QRecordEntityAssociation qRecordEntityAssociation : getAssociationList(this.getClass()))
+      {
+         @SuppressWarnings("unchecked")
+         List<? extends QRecordEntity> associatedEntities = (List<? extends QRecordEntity>) qRecordEntityAssociation.getGetter().invoke(this);
+         String associationName = qRecordEntityAssociation.getAssociationAnnotation().name();
+
+         if(associatedEntities != null)
+         {
+            outputRecord.withAssociatedRecords(associationName, new ArrayList<>());
+            for(QRecordEntity associatedEntity : associatedEntities)
+            {
+               outputRecord.withAssociatedRecord(associationName, toRecordFunction.apply(associatedEntity));
+            }
+         }
+      }
+   }
+
+
+
    /*******************************************************************************
-    **
+    ** Overload of toQRecordOnlyChangedFields that preserves original behavior of
+    ** that method, which is, to NOT includePrimaryKey
     *******************************************************************************/
+   @Deprecated(since = "includePrimaryKey param was added")
    public QRecord toQRecordOnlyChangedFields()
+   {
+      return toQRecordOnlyChangedFields(false);
+   }
+
+
+
+   /*******************************************************************************
+    ** Useful for the use-case of:
+    ** - fetch a QRecord (e.g., QueryAction or GetAction)
+    ** - build a QRecordEntity out of it
+    ** - change a field (or two) in it
+    ** - want to pass it into an UpdateAction, and want to see only the fields that
+    **   you know you changed get passed in to UpdateAction (e.g., PATCH semantics).
+    **
+    ** But also - per the includePrimaryKey param, include the primaryKey in the
+    ** records (e.g., to tell the Update which records to update).
+    **
+    ** Also, useful for:
+    ** - construct new entity, calling setters to populate some fields
+    ** - pass that entity into
+    *******************************************************************************/
+   public QRecord toQRecordOnlyChangedFields(boolean includePrimaryKey)
    {
       try
       {
          QRecord qRecord = new QRecord();
 
+         String primaryKeyFieldName = ObjectUtils.tryElse(() -> tableReferences.get(getClass().getName()).getPrimaryKeyField(), null);
+
          for(QRecordEntityField qRecordEntityField : getFieldList(this.getClass()))
          {
             Serializable thisValue     = (Serializable) qRecordEntityField.getGetter().invoke(this);
@@ -238,31 +295,16 @@ public abstract class QRecordEntity
                originalValue = originalRecordValues.get(qRecordEntityField.getFieldName());
             }
 
-            if(!Objects.equals(thisValue, originalValue))
+            ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+            // if this value and the original value don't match - OR - this is the table's primary key field - then put the value in the record. //
+            ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+            if(!Objects.equals(thisValue, originalValue) || (includePrimaryKey && Objects.equals(primaryKeyFieldName, qRecordEntityField.getFieldName())))
             {
                qRecord.setValue(qRecordEntityField.getFieldName(), thisValue);
             }
          }
 
-         for(QRecordEntityAssociation qRecordEntityAssociation : getAssociationList(this.getClass()))
-         {
-            @SuppressWarnings("unchecked")
-            List<? extends QRecordEntity> associatedEntities = (List<? extends QRecordEntity>) qRecordEntityAssociation.getGetter().invoke(this);
-            String                        associationName    = qRecordEntityAssociation.getAssociationAnnotation().name();
-
-            if(associatedEntities != null)
-            {
-               /////////////////////////////////////////////////////////////////////////////////
-               // do this so an empty list in the entity becomes an empty list in the QRecord //
-               /////////////////////////////////////////////////////////////////////////////////
-               qRecord.withAssociatedRecords(associationName, new ArrayList<>());
-            }
-
-            for(QRecordEntity associatedEntity : CollectionUtils.nonNullList(associatedEntities))
-            {
-               qRecord.withAssociatedRecord(associationName, associatedEntity.toQRecord());
-            }
-         }
+         toQRecordProcessAssociations(qRecord, (entity) -> entity.toQRecordOnlyChangedFields(includePrimaryKey));
 
          return (qRecord);
       }
@@ -284,13 +326,13 @@ public abstract class QRecordEntity
          List<QRecordEntityField> fieldList = new ArrayList<>();
          for(Method possibleGetter : c.getMethods())
          {
-            if(isGetter(possibleGetter))
+            if(ReflectiveBeanLikeClassUtils.isGetter(possibleGetter, true))
             {
-               Optional<Method> setter = getSetterForGetter(c, possibleGetter);
+               Optional<Method> setter = ReflectiveBeanLikeClassUtils.getSetterForGetter(c, possibleGetter);
 
                if(setter.isPresent())
                {
-                  String           fieldName       = getFieldNameFromGetter(possibleGetter);
+                  String           fieldName       = ReflectiveBeanLikeClassUtils.getFieldNameFromGetter(possibleGetter);
                   Optional<QField> fieldAnnotation = getQFieldAnnotation(c, fieldName);
 
                   if(fieldAnnotation.isPresent())
@@ -337,19 +379,19 @@ public abstract class QRecordEntity
          List<QRecordEntityAssociation> associationList = new ArrayList<>();
          for(Method possibleGetter : c.getMethods())
          {
-            if(isGetter(possibleGetter))
+            if(ReflectiveBeanLikeClassUtils.isGetter(possibleGetter, true))
             {
-               Optional<Method> setter = getSetterForGetter(c, possibleGetter);
+               Optional<Method> setter = ReflectiveBeanLikeClassUtils.getSetterForGetter(c, possibleGetter);
 
                if(setter.isPresent())
                {
-                  String                 fieldName             = getFieldNameFromGetter(possibleGetter);
+                  String                 fieldName             = ReflectiveBeanLikeClassUtils.getFieldNameFromGetter(possibleGetter);
                   Optional<QAssociation> associationAnnotation = getQAssociationAnnotation(c, fieldName);
 
                   if(associationAnnotation.isPresent())
                   {
                      @SuppressWarnings("unchecked")
-                     Class<? extends QRecordEntity> listTypeParam = (Class<? extends QRecordEntity>) getListTypeParam(possibleGetter.getReturnType(), possibleGetter.getAnnotatedReturnType());
+                     Class<? extends QRecordEntity> listTypeParam = (Class<? extends QRecordEntity>) ReflectiveBeanLikeClassUtils.getListTypeParam(possibleGetter.getReturnType(), possibleGetter.getAnnotatedReturnType());
                      associationList.add(new QRecordEntityAssociation(fieldName, possibleGetter, setter.get(), listTypeParam, associationAnnotation.orElse(null)));
                   }
                }
@@ -488,15 +530,16 @@ public abstract class QRecordEntity
    {
       // todo - more types!!
       return (returnType.equals(String.class)
-         || returnType.equals(Integer.class)
-         || returnType.equals(int.class)
-         || returnType.equals(Boolean.class)
-         || returnType.equals(boolean.class)
-         || returnType.equals(BigDecimal.class)
-         || returnType.equals(Instant.class)
-         || returnType.equals(LocalDate.class)
-         || returnType.equals(LocalTime.class)
-         || returnType.equals(byte[].class));
+              || returnType.equals(Integer.class)
+              || returnType.equals(Long.class)
+              || returnType.equals(int.class)
+              || returnType.equals(Boolean.class)
+              || returnType.equals(boolean.class)
+              || returnType.equals(BigDecimal.class)
+              || returnType.equals(Instant.class)
+              || returnType.equals(LocalDate.class)
+              || returnType.equals(LocalTime.class)
+              || returnType.equals(byte[].class));
       /////////////////////////////////////////////
       // note - this list has implications upon: //
       // - QFieldType.fromClass                  //
@@ -541,4 +584,31 @@ public abstract class QRecordEntity
       return (null);
    }
 
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   public static String getTableName(Class<? extends QRecordEntity> entityClass) throws QException
+   {
+      try
+      {
+         Field  tableNameField = entityClass.getDeclaredField("TABLE_NAME");
+         String tableNameValue = (String) tableNameField.get(null);
+         return (tableNameValue);
+      }
+      catch(Exception e)
+      {
+         throw (new QException("Could not get TABLE_NAME from entity class: " + entityClass.getSimpleName(), e));
+      }
+   }
+
+
+   /***************************************************************************
+    ** named without the 'get' to avoid conflict w/ entity fields named that...
+    ***************************************************************************/
+   public String tableName() throws QException
+   {
+      return (getTableName(this.getClass()));
+   }
+
 }

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

@@ -28,6 +28,7 @@ import java.math.BigDecimal;
 import java.time.Instant;
 import java.time.LocalDate;
 import java.time.LocalTime;
+import java.util.Map;
 import com.kingsrook.qqq.backend.core.exceptions.QValueException;
 import com.kingsrook.qqq.backend.core.utils.ValueUtils;
 
@@ -170,6 +171,11 @@ public class QRecordEntityField
          {
             return (ValueUtils.getValueAsByteArray(value));
          }
+
+         if(type.equals(Map.class))
+         {
+            return (ValueUtils.getValueAsMap(value));
+         }
       }
       catch(Exception e)
       {

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

@@ -0,0 +1,260 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2025.  Kingsrook, LLC
+ * 651 N Broad St Ste 205 # 6917 | Middletown DE 19709 | United States
+ * contact@kingsrook.com
+ * https://github.com/Kingsrook/
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.kingsrook.qqq.backend.core.model.data;
+
+
+import java.io.Serializable;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.BiFunction;
+
+
+/*******************************************************************************
+ ** Extension on QRecord, intended to be used where you've got records from
+ ** multiple tables, and you want to combine them into a single "wide" joined
+ ** record - but to do so without copying or modifying any of the individual
+ ** records.
+ **
+ ** e.g., given:
+ ** - Order (id, orderNo, orderDate) (main table)
+ ** - LineItem (id, sku, quantity)
+ ** - Extrinsic (id, key, value)
+ **
+ ** If set up in here as:
+ ** - new QRecordWithJoinedRecords(order)
+ **      .withJoinedRecordValues(lineItem)
+ **      .withJoinedRecordValues(extrinsic)
+ **
+ ** Then we'd have the appearance of values in the object like:
+ ** - id, orderNo, orderDate, lineItem.id, lineItem.sku, lineItem.quantity, extrinsic.id, extrinsic.key, extrinsic.value
+ **
+ ** Which, by the by, is how a query that returns joined records looks, and, is
+ ** what BackendQueryFilterUtils can use to do filter.
+ **
+ ** This is done without copying or mutating any of the records (which, if you just use
+ ** QRecord.withJoinedRecordValues, then those values are copied into the main record)
+ ** - because this object is just storing references to the input records.
+ **
+ ** Note that this implies that, values changed in this record (e.g, calls to setValue)
+ ** WILL impact the underlying records!
+ *******************************************************************************/
+public class QRecordWithJoinedRecords extends QRecord
+{
+   private QRecord              mainRecord;
+   private Map<String, QRecord> components = new LinkedHashMap<>();
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   public QRecordWithJoinedRecords(QRecord mainRecord)
+   {
+      this.mainRecord = mainRecord;
+   }
+
+
+
+   /*************************************************************************
+    **
+    ***************************************************************************/
+   @Override
+   public void addJoinedRecordValues(String joinTableName, QRecord joinedRecord)
+   {
+      components.put(joinTableName, joinedRecord);
+   }
+
+
+
+   /*************************************************************************
+    **
+    ***************************************************************************/
+   public QRecordWithJoinedRecords withJoinedRecordValues(QRecord record, String joinTableName)
+   {
+      addJoinedRecordValues(joinTableName, record);
+      return (this);
+   }
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   @Override
+   public Serializable getValue(String fieldName)
+   {
+      return performFunctionOnRecordBasedOnFieldName(fieldName, ((record, f) -> record.getValue(f)));
+   }
+
+
+
+   /***************************************************************************
+    *
+    ***************************************************************************/
+   @Override
+   public void setValue(String fieldName, Object value)
+   {
+      performFunctionOnRecordBasedOnFieldName(fieldName, ((record, f) ->
+      {
+         record.setValue(f, value);
+         return (null);
+      }));
+   }
+
+
+
+   /***************************************************************************
+    *
+    ***************************************************************************/
+   @Override
+   public void setValue(String fieldName, Serializable value)
+   {
+      performFunctionOnRecordBasedOnFieldName(fieldName, ((record, f) ->
+      {
+         record.setValue(f, value);
+         return (null);
+      }));
+   }
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   @Override
+   public void removeValue(String fieldName)
+   {
+      performFunctionOnRecordBasedOnFieldName(fieldName, ((record, f) ->
+      {
+         record.removeValue(f);
+         return (null);
+      }));
+   }
+
+
+
+   /***************************************************************************
+    ** avoid having this same block in all the functions that call it...
+    ** given a fieldName, which may be a joinTable.fieldName, apply the function
+    ** to the right entity.
+    ***************************************************************************/
+   private Serializable performFunctionOnRecordBasedOnFieldName(String fieldName, BiFunction<QRecord, String, Serializable> functionToPerform)
+   {
+      if(fieldName.contains("."))
+      {
+         String[] parts     = fieldName.split("\\.");
+         QRecord  component = components.get(parts[0]);
+         if(component != null)
+         {
+            return functionToPerform.apply(component, parts[1]);
+         }
+         else
+         {
+            return null;
+         }
+      }
+      else
+      {
+         return functionToPerform.apply(mainRecord, fieldName);
+      }
+   }
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   @Override
+   public Map<String, Serializable> getValues()
+   {
+      Map<String, Serializable> rs = new LinkedHashMap<>(mainRecord.getValues());
+      for(Map.Entry<String, QRecord> componentEntry : components.entrySet())
+      {
+         String  joinTableName   = componentEntry.getKey();
+         QRecord componentRecord = componentEntry.getValue();
+         for(Map.Entry<String, Serializable> entry : componentRecord.getValues().entrySet())
+         {
+            rs.put(joinTableName + "." + entry.getKey(), entry.getValue());
+         }
+      }
+      return (rs);
+   }
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   @Override
+   public Map<String, List<QRecord>> getAssociatedRecords()
+   {
+      return mainRecord.getAssociatedRecords();
+   }
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   @Override
+   public QRecord withAssociatedRecord(String name, QRecord associatedRecord)
+   {
+      mainRecord.withAssociatedRecord(name, associatedRecord);
+      return (this);
+   }
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   @Override
+   public QRecord withAssociatedRecords(Map<String, List<QRecord>> associatedRecords)
+   {
+      mainRecord.withAssociatedRecords(associatedRecords);
+      return (this);
+   }
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   @Override
+   public void setAssociatedRecords(Map<String, List<QRecord>> associatedRecords)
+   {
+      mainRecord.setAssociatedRecords(associatedRecords);
+   }
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   @Override
+   public QRecord withAssociatedRecords(String name, List<QRecord> associatedRecords)
+   {
+      mainRecord.withAssociatedRecords(name, associatedRecords);
+      return (this);
+   }
+
+}

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

@@ -82,6 +82,7 @@ public class HelpContentMetaDataProvider
       table.getField("key").withFieldAdornment(AdornmentType.Size.LARGE.toAdornment());
       table.getField("content").withFieldAdornment(AdornmentType.Size.LARGE.toAdornment());
       table.getField("content").withFieldAdornment(new FieldAdornment(AdornmentType.CODE_EDITOR).withValue(AdornmentType.CodeEditorValues.languageMode("html")));
+      table.getField("content").withGridColumns(12);
 
       if(backendDetailEnricher != null)
       {

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

@@ -0,0 +1,47 @@
+/*
+ * QQQ - Low-code Application Framework for Engineers.
+ * Copyright (C) 2021-2025.  Kingsrook, LLC
+ * 651 N Broad St Ste 205 # 6917 | Middletown DE 19709 | United States
+ * contact@kingsrook.com
+ * https://github.com/Kingsrook/
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.kingsrook.qqq.backend.core.model.metadata;
+
+
+import com.kingsrook.qqq.backend.core.logging.QLogger;
+
+
+/*******************************************************************************
+ ** for use-cases where a metaDataProducer directly adds its objects to the
+ ** qInstance, then this empty object can be returned.
+ *******************************************************************************/
+public class EmptyMetaDataProducerOutput implements MetaDataProducerOutput
+{
+   private static final QLogger LOG = QLogger.getLogger(EmptyMetaDataProducerOutput.class);
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   @Override
+   public void addSelfToInstance(QInstance instance)
+   {
+      /////////////////////////////////
+      // noop - this output is empty //
+      /////////////////////////////////
+      LOG.trace("empty meta data producer has nothing to add.");
+   }
+}

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

@@ -24,10 +24,45 @@ package com.kingsrook.qqq.backend.core.model.metadata;
 
 /*******************************************************************************
  ** Abstract class that knows how to produce meta data objects.  Useful with
- ** MetaDataProducerHelper, to put point at a package full of these, and populate
+ ** MetaDataProducerHelper, to point at a package full of these, and populate
  ** your whole QInstance.
  *******************************************************************************/
 public abstract class MetaDataProducer<T extends MetaDataProducerOutput> implements MetaDataProducerInterface<T>
 {
+   private Class<?> sourceClass;
+
+
+   /*******************************************************************************
+    ** Getter for sourceClass
+    **
+    *******************************************************************************/
+   @Override
+   public Class<?> getSourceClass()
+   {
+      return sourceClass;
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for sourceClass
+    **
+    *******************************************************************************/
+   @Override
+   public void setSourceClass(Class<?> sourceClass)
+   {
+      this.sourceClass = sourceClass;
+   }
+
+
+   /*******************************************************************************
+    ** Fluent setter for sourceClass
+    **
+    *******************************************************************************/
+   public MetaDataProducer<T> withSourceClass(Class<?> sourceClass)
+   {
+      this.sourceClass = sourceClass;
+      return (this);
+   }
 
 }

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

@@ -22,7 +22,9 @@
 package com.kingsrook.qqq.backend.core.model.metadata;
 
 
+import java.io.Serializable;
 import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
 import java.lang.reflect.Modifier;
 import java.util.ArrayList;
 import java.util.Comparator;
@@ -31,10 +33,26 @@ import java.util.List;
 import java.util.Map;
 import com.kingsrook.qqq.backend.core.exceptions.QException;
 import com.kingsrook.qqq.backend.core.logging.QLogger;
+import com.kingsrook.qqq.backend.core.model.data.QField;
+import com.kingsrook.qqq.backend.core.model.data.QRecordEntity;
 import com.kingsrook.qqq.backend.core.model.metadata.dashboard.QWidgetMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.joins.QJoinMetaData;
 import com.kingsrook.qqq.backend.core.model.metadata.layout.QAppMetaData;
+import com.kingsrook.qqq.backend.core.model.metadata.possiblevalues.PossibleValueEnum;
+import com.kingsrook.qqq.backend.core.model.metadata.producers.ChildJoinFromRecordEntityGenericMetaDataProducer;
+import com.kingsrook.qqq.backend.core.model.metadata.producers.ChildRecordListWidgetFromRecordEntityGenericMetaDataProducer;
+import com.kingsrook.qqq.backend.core.model.metadata.producers.MetaDataCustomizerInterface;
+import com.kingsrook.qqq.backend.core.model.metadata.producers.PossibleValueSourceOfEnumGenericMetaDataProducer;
+import com.kingsrook.qqq.backend.core.model.metadata.producers.PossibleValueSourceOfTableGenericMetaDataProducer;
+import com.kingsrook.qqq.backend.core.model.metadata.producers.RecordEntityToTableGenericMetaDataProducer;
+import com.kingsrook.qqq.backend.core.model.metadata.producers.annotations.ChildRecordListWidget;
+import com.kingsrook.qqq.backend.core.model.metadata.producers.annotations.ChildTable;
+import com.kingsrook.qqq.backend.core.model.metadata.producers.annotations.QMetaDataProducingEntity;
+import com.kingsrook.qqq.backend.core.model.metadata.producers.annotations.QMetaDataProducingPossibleValueEnum;
+import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
 import com.kingsrook.qqq.backend.core.utils.ClassPathUtils;
+import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
+import com.kingsrook.qqq.backend.core.utils.StringUtils;
 import static com.kingsrook.qqq.backend.core.logging.LogUtils.logPair;
 
 
@@ -68,13 +86,30 @@ public class MetaDataProducerHelper
       comparatorValuesByType.put(QAppMetaData.class, 23);
    }
 
+   private static MetaDataCustomizerInterface<QTableMetaData> tableMetaDataCustomizer = null;
+
+
+
    /*******************************************************************************
     ** Recursively find all classes in the given package, that implement MetaDataProducerInterface
-    ** run them, and add their output to the given qInstance.
+    ** run them, and add their output to the given qInstance - using the provided
+    ** tableMetaDataCustomizer to help with all RecordEntity's that
+    ** are configured to make tables.
     **
     ** Note - they'll be sorted by the sortOrder they provide.
     *******************************************************************************/
-   public static void processAllMetaDataProducersInPackage(QInstance instance, String packageName) throws QException
+   public static void processAllMetaDataProducersInPackage(QInstance instance, String packageName, MetaDataCustomizerInterface<QTableMetaData> tableMetaDataCustomizer) throws QException
+   {
+      MetaDataProducerHelper.tableMetaDataCustomizer = tableMetaDataCustomizer;
+      processAllMetaDataProducersInPackage(instance, packageName);
+      MetaDataProducerHelper.tableMetaDataCustomizer = null;
+   }
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   public static List<MetaDataProducerInterface<?>> findProducers(String packageName) throws QException
    {
       List<Class<?>> classesInPackage;
       try
@@ -90,6 +125,9 @@ public class MetaDataProducerHelper
       }
       List<MetaDataProducerInterface<?>> producers = new ArrayList<>();
 
+      ////////////////////////////////////////////////////////////////////////////////////////
+      // loop over classes, processing them based on either their type or their annotations //
+      ////////////////////////////////////////////////////////////////////////////////////////
       for(Class<?> aClass : classesInPackage)
       {
          try
@@ -99,25 +137,36 @@ public class MetaDataProducerHelper
                continue;
             }
 
+            /////////////////////////////////////////////////////////////////////
+            // handle classes which are themselves MetaDataProducerInterface's //
+            /////////////////////////////////////////////////////////////////////
             if(MetaDataProducerInterface.class.isAssignableFrom(aClass))
             {
-               boolean foundValidConstructor = false;
-               for(Constructor<?> constructor : aClass.getConstructors())
-               {
-                  if(constructor.getParameterCount() == 0)
-                  {
-                     Object o = constructor.newInstance();
-                     producers.add((MetaDataProducerInterface<?>) o);
-                     foundValidConstructor = true;
-                     break;
-                  }
-               }
+               CollectionUtils.addIfNotNull(producers, processMetaDataProducer(aClass));
+            }
 
-               if(!foundValidConstructor)
+            /////////////////////////////////////////////////////////////////////////
+            // handle classes that have the @QMetaDataProducingEntity annotation - //
+            // record entities that should produce meta-data                       //
+            /////////////////////////////////////////////////////////////////////////
+            if(aClass.isAnnotationPresent(QMetaDataProducingEntity.class))
+            {
+               producers.addAll(processMetaDataProducingEntity(aClass));
+            }
+
+            //////////////////////////////////////////////////////////////////
+            // handle classes with the @QMetaDataProducingPossibleValueEnum //
+            // enums that are PVS's                                         //
+            //////////////////////////////////////////////////////////////////
+            if(aClass.isAnnotationPresent(QMetaDataProducingPossibleValueEnum.class))
+            {
+               QMetaDataProducingPossibleValueEnum qMetaDataProducingPossibleValueEnum = aClass.getAnnotation(QMetaDataProducingPossibleValueEnum.class);
+               if(qMetaDataProducingPossibleValueEnum.producePossibleValueSource())
                {
-                  LOG.warn("Found a class which implements MetaDataProducerInterface, but it does not have a no-arg constructor, so it cannot be used.", logPair("class", aClass.getSimpleName()));
+                  CollectionUtils.addIfNotNull(producers, processMetaDataProducingPossibleValueEnum(aClass));
                }
             }
+
          }
          catch(Exception e)
          {
@@ -143,6 +192,20 @@ public class MetaDataProducerHelper
             }
          }));
 
+      return (producers);
+   }
+
+
+   /*******************************************************************************
+    ** Recursively find all classes in the given package, that implement MetaDataProducerInterface
+    ** run them, and add their output to the given qInstance.
+    **
+    ** Note - they'll be sorted by the sortOrder they provide.
+    *******************************************************************************/
+   public static void processAllMetaDataProducersInPackage(QInstance instance, String packageName) throws QException
+   {
+      List<MetaDataProducerInterface<?>> producers = findProducers(packageName);
+
       ///////////////////////////////////////////////////////////////////////////
       // execute each one (if enabled), adding their meta data to the instance //
       ///////////////////////////////////////////////////////////////////////////
@@ -168,7 +231,264 @@ public class MetaDataProducerHelper
             LOG.debug("Not using producer which is not enabled", logPair("producer", producer.getClass().getSimpleName()));
          }
       }
+   }
 
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   @SuppressWarnings("unchecked")
+   private static <T extends Serializable & PossibleValueEnum<T>> MetaDataProducerInterface<?> processMetaDataProducingPossibleValueEnum(Class<?> sourceClass)
+   {
+      String warningPrefix = "Found a class annotated as @" + QMetaDataProducingPossibleValueEnum.class.getSimpleName();
+      if(!PossibleValueEnum.class.isAssignableFrom(sourceClass))
+      {
+         LOG.warn(warningPrefix + ", but which is not a " + PossibleValueEnum.class.getSimpleName() + ", so it will not be used.", logPair("class", sourceClass.getSimpleName()));
+         return null;
+      }
+
+      PossibleValueEnum<?>[] values = (PossibleValueEnum<?>[]) sourceClass.getEnumConstants();
+      PossibleValueSourceOfEnumGenericMetaDataProducer<T> producer = new PossibleValueSourceOfEnumGenericMetaDataProducer<>(sourceClass.getSimpleName(), (PossibleValueEnum<T>[]) values);
+      producer.setSourceClass(sourceClass);
+      return producer;
+   }
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   private static List<MetaDataProducerInterface<?>> processMetaDataProducingEntity(Class<?> sourceClass) throws Exception
+   {
+      List<MetaDataProducerInterface<?>> rs = new ArrayList<>();
+
+      QMetaDataProducingEntity qMetaDataProducingEntity = sourceClass.getAnnotation(QMetaDataProducingEntity.class);
+      String                   warningPrefix            = "Found a class annotated as @" + QMetaDataProducingEntity.class.getSimpleName();
+
+      ///////////////////////////////////////////////////////////
+      // make sures class is QRecordEntity and cast it as such //
+      ///////////////////////////////////////////////////////////
+      if(!QRecordEntity.class.isAssignableFrom(sourceClass))
+      {
+         LOG.warn(warningPrefix + ", but which is not a " + QRecordEntity.class.getSimpleName() + ", so it will not be used.", logPair("class", sourceClass.getSimpleName()));
+         return (rs);
+      }
+
+      @SuppressWarnings("unchecked") // safe per the check above.
+      Class<? extends QRecordEntity> recordEntityClass = (Class<? extends QRecordEntity>) sourceClass;
+
+      ////////////////////////////////////////////////
+      // get TABLE_NAME static field from the class //
+      ////////////////////////////////////////////////
+      Field tableNameField = recordEntityClass.getDeclaredField("TABLE_NAME");
+      if(!tableNameField.getType().equals(String.class))
+      {
+         LOG.warn(warningPrefix + ", but whose TABLE_NAME field is not a String, so it will not be used.", logPair("class", recordEntityClass.getSimpleName()));
+         return (rs);
+      }
+
+      String tableNameValue = (String) tableNameField.get(null);
+
+      //////////////////////////////////////////
+      // add table producer, if so configured //
+      //////////////////////////////////////////
+      if(qMetaDataProducingEntity.produceTableMetaData())
+      {
+         try
+         {
+            Class<? extends MetaDataCustomizerInterface<?>>              genericMetaProductionCustomizer   = (Class<? extends MetaDataCustomizerInterface<?>>) qMetaDataProducingEntity.tableMetaDataCustomizer();
+            Class<? extends MetaDataCustomizerInterface<QTableMetaData>> tableMetaDataProductionCustomizer = null;
+            if(!genericMetaProductionCustomizer.equals(MetaDataCustomizerInterface.NoopMetaDataCustomizer.class))
+            {
+               tableMetaDataProductionCustomizer = (Class<? extends MetaDataCustomizerInterface<QTableMetaData>>) genericMetaProductionCustomizer;
+            }
+
+            RecordEntityToTableGenericMetaDataProducer producer = new RecordEntityToTableGenericMetaDataProducer(tableNameValue, recordEntityClass, tableMetaDataProductionCustomizer);
+            producer.setSourceClass(recordEntityClass);
+
+            if(tableMetaDataCustomizer != null)
+            {
+               producer.addRecordEntityTableMetaDataProductionCustomizer(tableMetaDataCustomizer);
+            }
+
+            rs.add(producer);
+         }
+         catch(Exception e)
+         {
+            throw new QException("Error processing table meta data producer for entity class: " + recordEntityClass.getName(), e);
+         }
+      }
+
+      ////////////////////////////////////////
+      // add PVS producer, if so configured //
+      ////////////////////////////////////////
+      if(qMetaDataProducingEntity.producePossibleValueSource())
+      {
+         PossibleValueSourceOfTableGenericMetaDataProducer producer = new PossibleValueSourceOfTableGenericMetaDataProducer(tableNameValue);
+         producer.setSourceClass(recordEntityClass);
+         rs.add(producer);
+      }
+
+      //////////////////////////
+      // process child tables //
+      //////////////////////////
+      for(ChildTable childTable : qMetaDataProducingEntity.childTables())
+      {
+         Class<? extends QRecordEntity> childEntityClass = childTable.childTableEntityClass();
+         if(childTable.childJoin().enabled())
+         {
+            CollectionUtils.addIfNotNull(rs, processChildJoin(recordEntityClass, childTable));
+
+            if(childTable.childRecordListWidget().enabled())
+            {
+               CollectionUtils.addIfNotNull(rs, processChildRecordListWidget(recordEntityClass, childTable));
+            }
+         }
+         else
+         {
+            if(childTable.childRecordListWidget().enabled())
+            {
+               //////////////////////////////////////////////////////////////////////////
+               // if not doing the join, can't do the child-widget, so warn about that //
+               //////////////////////////////////////////////////////////////////////////
+               LOG.warn(warningPrefix + " requested to produce a ChildRecordListWidget, but not produce a Join - which is not allowed (must do join to do widget). ", logPair("class", recordEntityClass.getSimpleName()), logPair("childEntityClass", childEntityClass.getSimpleName()));
+            }
+         }
+      }
+
+      return (rs);
+   }
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   private static MetaDataProducerInterface<?> processChildRecordListWidget(Class<? extends QRecordEntity> sourceClass, ChildTable childTable) throws Exception
+   {
+      Class<? extends QRecordEntity> childEntityClass = childTable.childTableEntityClass();
+      String                         parentTableName  = getTableNameStaticFieldValue(sourceClass);
+      String                         childTableName   = getTableNameStaticFieldValue(childEntityClass);
+
+      ChildRecordListWidget childRecordListWidget = childTable.childRecordListWidget();
+      ChildRecordListWidgetFromRecordEntityGenericMetaDataProducer producer = new ChildRecordListWidgetFromRecordEntityGenericMetaDataProducer(childTableName, parentTableName, childRecordListWidget);
+      producer.setSourceClass(sourceClass);
+      return producer;
+   }
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   private static String findPossibleValueField(Class<? extends QRecordEntity> entityClass, String possibleValueSourceName)
+   {
+      for(Field field : entityClass.getDeclaredFields())
+      {
+         if(field.isAnnotationPresent(QField.class))
+         {
+            QField qField = field.getAnnotation(QField.class);
+            if(qField.possibleValueSourceName().equals(possibleValueSourceName))
+            {
+               return field.getName();
+            }
+         }
+      }
+
+      return (null);
+   }
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   private static MetaDataProducerInterface<?> processChildJoin(Class<? extends QRecordEntity> entityClass, ChildTable childTable) throws Exception
+   {
+      Class<? extends QRecordEntity> childEntityClass = childTable.childTableEntityClass();
+
+      String parentTableName        = getTableNameStaticFieldValue(entityClass);
+      String childTableName         = getTableNameStaticFieldValue(childEntityClass);
+      String possibleValueFieldName = findPossibleValueField(childEntityClass, parentTableName);
+      if(!StringUtils.hasContent(possibleValueFieldName))
+      {
+         LOG.warn("Could not find field in [" + childEntityClass.getSimpleName() + "] with possibleValueSource referencing table [" + entityClass.getSimpleName() + "]");
+         return (null);
+      }
+
+      ChildJoinFromRecordEntityGenericMetaDataProducer producer = new ChildJoinFromRecordEntityGenericMetaDataProducer(childTableName, parentTableName, possibleValueFieldName, childTable.childJoin().orderBy());
+      producer.setSourceClass(entityClass);
+      return producer;
+   }
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   private static MetaDataProducerInterface<?> processMetaDataProducer(Class<?> sourceCClass) throws Exception
+   {
+      for(Constructor<?> constructor : sourceCClass.getConstructors())
+      {
+         if(constructor.getParameterCount() == 0)
+         {
+            Object o = constructor.newInstance();
+            MetaDataProducerInterface<?> producer = (MetaDataProducerInterface<?>) o;
+            producer.setSourceClass(sourceCClass);
+            return producer;
+         }
+      }
+
+      LOG.warn("Found a class which implements MetaDataProducerInterface, but it does not have a no-arg constructor, so it cannot be used.", logPair("class", sourceCClass.getSimpleName()));
+      return null;
+   }
+
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   private static String getTableNameStaticFieldValue(Class<?> aClass) throws NoSuchFieldException, IllegalAccessException
+   {
+      Field tableNameField = aClass.getDeclaredField("TABLE_NAME");
+      if(!tableNameField.getType().equals(String.class))
+      {
+         return (null);
+      }
+
+      String tableNameValue = (String) tableNameField.get(null);
+      return (tableNameValue);
+   }
+
+
+
+   /*******************************************************************************
+    ** Getter for tableMetaDataCustomizer
+    *******************************************************************************/
+   public MetaDataCustomizerInterface<QTableMetaData> getTableMetaDataCustomizer()
+   {
+      return (MetaDataProducerHelper.tableMetaDataCustomizer);
+   }
+
+
+
+   /*******************************************************************************
+    ** Setter for tableMetaDataCustomizer
+    *******************************************************************************/
+   public void setTableMetaDataCustomizer(MetaDataCustomizerInterface<QTableMetaData> tableMetaDataCustomizer)
+   {
+      MetaDataProducerHelper.tableMetaDataCustomizer = tableMetaDataCustomizer;
+   }
+
+
+
+   /*******************************************************************************
+    ** Fluent setter for tableMetaDataCustomizer
+    *******************************************************************************/
+   public void withTableMetaDataCustomizer(MetaDataCustomizerInterface<QTableMetaData> tableMetaDataCustomizer)
+   {
+      MetaDataProducerHelper.tableMetaDataCustomizer = tableMetaDataCustomizer;
    }
 
 }

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

@@ -27,12 +27,12 @@ import com.kingsrook.qqq.backend.core.exceptions.QException;
 
 /*******************************************************************************
  ** Interface for classes that know how to produce meta data objects.  Useful with
- ** MetaDataProducerHelper, to put point at a package full of these, and populate
+ ** MetaDataProducerHelper, to point at a package full of these, and populate
  ** your whole QInstance.
  **
  ** See also MetaDataProducer - an implementer of this interface, which actually
  ** came first, and is fine to extend if producing a meta-data class is all your
- ** clas means to do (nice and "Single-responsibility principle").
+ ** class means to do (nice and "Single-responsibility principle").
  **
  ** But, in some applications you may want to, for example, have one class that
  ** defines a process step, and also produces the meta-data for that process, so
@@ -73,4 +73,23 @@ public interface MetaDataProducerInterface<T extends MetaDataProducerOutput>
       return (true);
    }
 
+
+   /***************************************************************************
+    *
+    ***************************************************************************/
+   default void setSourceClass(Class<?> sourceClass)
+   {
+      //////////
+      // noop //
+      //////////
+   }
+
+
+   /***************************************************************************
+    **
+    ***************************************************************************/
+   default Class<?> getSourceClass()
+   {
+      return null;
+   }
 }