All Classes and Interfaces
Class
Description
Base input class for all Q actions.
Abstract base class for any qqq-action's output.
Base class for the AI tools the kernel runs.
Base class for all Backend-module-API Actions
Base class for all Filesystem actions across all modules.
Base class for the data returned in rendering a block of a specific type.
Base class for individual endpoint specs.
Base class for the Extract logic of Streamed ETL processes.
Base class for all (local) Filesystem actions
Base class for all BackendMetaData for all filesystem-style backend modules.
Extension of QTableBackendDetails, with details specific to a Filesystem table.
Base class for rendering qqq HTML dashboard widgets
Base for extension endpoint specs whose request is path/query parameters and
an optional JSON object body, and whose response is a JSON value - the
common shape of module and qbit endpoints.
runs the spec's handle()
The request: path parameters, the first value of each query parameter,
and the JSON body (empty unless the spec defines one).
the response body
output interface
Base class for the Load (aka, store) logic of Streamed ETL processes.
Base for key providers that look up base64 text by name.
Base class for all core actions in the Memory backend module.
This class is for merging duplicate records in a table.
Record to store the config for this process - e.g., what fields invalid input: '&' tables are used.
Abstract base class in hierarchy of classes that know how to construct invalid input: '&'
populate QMetaDataObject instances, based on input streams (e.g., from files).
Version of AbstractQQQApplication that assumes all meta-data is produced
by MetaDataProducers in (or under) a single package.
Baseclass that combines multiple specs together into a single "version" of
the full qqq middleware.
Base class for all mongoDB module actions.
Abstract class that a table can specify an implementation of, to provide
custom actions after a delete takes place.
Abstract class that a table can specify an implementation of, to provide
custom actions after an insert takes place.
after a file is read, "customize" its contents - e.g., do regex, or append
contents, or do whatever we like to it.
Abstract class that a table can specify an implementation of, to provide
custom actions after an update takes place.
Abstract class that a table can specify an implementation of, to provide
custom actions before a delete takes place.
Abstract class that a table can specify an implementation of, to provide
custom actions before an insert takes place.
allow the customizer to specify when it should be executed as part of the
insert action.
Abstract class that a table can specify an implementation of, to provide
custom actions before an update takes place.
Base class for QQQ Actions (both framework and application defined) that
have a signature like a BiConsumer - taking both Input and Output objects as
parameters, with void output.
Base class for QQQ Actions (both framework and application defined) that
have a signature like a Function - taking an Input object as a parameter,
and returning an Output object.
For bulk-loads, define where a QField comes from in an input data source.
Enum to define the types of sources a mapping may use
Base class to provide the definition of a QQQ-based application.
Base class for all core actions in the RDBMS module.
Base class to manage creating scheduled jobs based on records in another table
Expected to be used via BaseSyncToScheduledJobTableCustomizer - see its javadoc.
action flags that can be put in an insert/update/delete input to control
behavior of this process.
Base class for input wrappers that end up running scripts (ExecuteCodeAction)
Base class for all S3 filesystem actions
Base class for all SFTP filesystem actions
Base class for input for any qqq action that works against a table.
This class is for transforming records from a Source table to a Destination table.
Record to store the config for this process - e.g., what fields invalid input: '&' tables are used.
Base class for the Transform logic of Streamed ETL processes.
Base class for rendering qqq dashboard widgets
Custom HTML and derived text cannot be masked automatically.
Exception thrown doing authentication
interface to mark enums (presumably classes too, but the original intent is
enums) that can be added to insert/update/delete action inputs to flag behaviors
Utility methods to be shared by all of the various Actions (e.g., InsertAction)
For actions that may want to set a timeout, and cancel themselves if they run
too long - this class helps.
Which network addresses an outbound request may reach.
Types of adornments that can be added to fields - with utilities for
constructing their values.
Values for a FILE_PREVIEW adornment, which makes a field render as a
thumbnail (for images) or a file-type icon (for other files), where
clicking opens a preview (lightbox) of the full-size file.
Define an "aggregate", e.g., to be selected in an Aggregate action.
Generic widget that does an aggregate query, and presents its results
as a table, using group-by values as both row invalid input: '&' column labels.
Incremental aggregate state shared by memory and streamed execution.
Action to run an aggregate against a table.
Shared validation, result types and bucket semantics for aggregate execution.
Aggregate analysis metadata.
Input data for the Count action
Interface for the Aggregate action.
Output for an aggregate action
Classes that support doing data aggregations (e.g., count, sum, min, max, average).
What the AI tool kernel may do with a table (and optionally one record) for
one user - built by
AiToolKernel.describeAccess(com.kingsrook.qqq.backend.core.model.session.QSession, java.lang.String, java.io.Serializable), e.g. for the record
Developer screen.Resolve AI data classifications without changing metadata or exposure policy.
Wraps tool output (JSON text) in the data envelope the assistant's system
prompt declares as untrusted data:
{...}
Any opening or closing qqq_data tag inside the data (e.g., injected into a
record's text by a user) is neutralized by replacing its "<" with the JSON
escape for that character - which keeps the JSON valid and equal in value,
but means the text can no longer close (or open) an envelope.
How the AI tool kernel's data tools read data.
How much of a table or field the AI tool kernel may expose to a model.
The assistant's default field policy, also used outside the AI kernel.
Default assistant-channel exposure, from explicit
AiTableMetaData /
AiFieldMetaData or conservative defaults.Compatibility view of the core FieldAccessHelper decision and why: "hidden",
"password", "field security lock", "metadata" (explicit AiFieldMetaData),
"table" (capped by the table's exposure) or "default".
Supplemental field meta-data (type "ai") for the AI tool kernel: how much of
the field is exposed to a model, and an optional description written for a
model (aiDescription).
The strict filter schema of the AI tools (spec Appendix A: a boolean
operator, criteria, and at most one level of sub-filters - strict schemas
can't be recursive), and its translation to a
QQueryFilter.Plain-text renderings of QQQ help content (HTML, markdown or text), for the
model: tags removed, whitespace collapsed, length limited.
Small builders for the strict JSON Schemas of AI tool inputs.
Builds the in-app (same-origin) links the AI tool kernel returns, in the
route grammar of the QQQ Next UI - which addresses every table, process,
report and app by name directly under /app (not under the path of the app
that contains it):
table /app/{table}
filtered table /app/{table}?
A reference to one record, for the UI to render as a chip that deep-links to
the record (href is an in-app path, like /app/{table}/{id}).
Replaces secrets and PII in values sent to a model with [REDACTED:kind]:
private keys, JWTs, API keys (sk-...), AWS access keys and (labelled) secret
keys, US social security numbers, payment card numbers (Luhn-valid, 13-19
digits) and any custom patterns (kind "custom").
Supplemental table meta-data (type "ai") for the AI tool kernel: how much of
the table is exposed to a model, and an optional description written for a
model (aiDescription), used by describe_table, search_help and the app
digest.
Whether one AI tool applies to a table (or record) for a user, and why not.
One call of an AI tool, as requested by a model: the provider's tool-call
id, the tool's wire name, and its (parsed JSON) input object.
Per-call context for an AI tool: the kernel's instance, settings, exposure
policy and redactor, the result being built - and the shared checks and
output shaping every tool uses (so no tool can forget one):
- visibility (the meta-data customizer, and DENY_HIDE) and exposure checks,
- the table READ permission check (recorded in the result's permissionCheck),
- action-input preparation (input source USER, omit hidden fields, mask
passwords, and the core-enforcement hook),
- value shaping: exposure post-filter, masking, redaction and truncation.
Definition of one AI tool, as advertised to a model: its wire name, a
description, its kind, and a strict JSON Schema for its input (an object
schema with additionalProperties=false and a required list).
Thrown by an AI tool to end its call with a non-OK outcome (DENIED,
NOT_FOUND, INVALID_INPUT) and a polite message for the model.
Typed, validating access to the (untrusted) input object of an AI tool call.
The AI tool kernel: the one permission-checked path through which an AI
model (the in-app assistant, an MCP server, ...) reads QQQ data.
Settings for an
AiToolKernel.The kind of an AI tool: what class of effect running it can have.
The outcome of running an AI tool call through the
AiToolKernel.Tools contributed to the AI tool kernel by qbits and applications.
The result of running one AI tool call through the
AiToolKernel.Masks values of fields whose exposure is MASKED:
- email addresses keep their first character and their domain (j***@example.com)
- numbers, and strings of digits (and separators), keep their last 4 digits (***1234)
- other strings keep their first and last character (a***z), or are fully
masked (***) when 4 or fewer characters long.
Model containing datastructure expected by frontend alert widget
A monitor that an alert type ships with ("seeded").
A link from an alert to where a person fixes it: a record, a table with a
filter, an app or widget path, or an absolute URL.
The kinds of monitor an alerts implementation evaluates.
Turns process lifecycle events into alerts, for processes that carry
AlertProcessMetaData (registered automatically by its enrichment):
- a failed run raises process.
"Tell me when this process fails" and "tell me when it didn't run", by
meta-data alone:
process.withSupplementalMetaData(new AlertProcessMetaData()
.withAlertOnFailure(AlertSeverity.ERROR)
.withExpectedEvery(Duration.ofHours(24)));
At enrichment this declares the alert types process.
A record that an alert is about.
A producer's "this problem is gone", passed to QAlerts.resolve.
How urgent an alert is.
One "this is a problem" signal from a producer, passed to QAlerts.raise.
Where QAlerts sends signals.
Instance-level alerts meta-data: the sink that QAlerts sends signals to
(default: LoggingAlertSink) and every declared QAlertTypeMetaData.
Widget that can add an Alert to a process screen.
Comparator for strings that are a mix of alpha + numeric, where we want to
sort the numeric substrings like numbers.
Meant to serve as the key in a Memoization where we actually don't need a parameter.
Meta-data to provide details of an API backend (e.g., connection params)
QQQ Backend module for working with API's (e.g., over http(s)).
settings that the API backend module can get from a backend variant.
optional interface that can be added to an ApiFieldCustomValueMapper to
signal that the customizer knows how to work in bulk.
utility methods for working with fields
HTTP behaviour of an API instance served to the public internet, typically
behind a CDN: shared-cache headers and validators for anonymous reads, and an
explicit CORS policy.
Applies an
ApiHttpPolicy to requests and responses of one API
instance: CORS before the request is handled, cache headers and validators
after.In addition to the standard/known fields in this entity, you can also add
name/value pairs of security key values - e.g., a clientId field
implementation of ApiOutputRecordWrapperInterface that wraps a Map
implementation of ApiOutputRecordWrapperInterface that wraps a QRecord
interface to define wrappers for either a Map of values (e.g., the
original/native return type for the API), or a QRecord.
Utilities for working with Query Filters in the API (e.g., versioned field fun)
Object injected into script context, for interfacing with a QQQ API.
Extension of QTableBackendDetails, with details specific to an API table.
Should work as well for https://semver.org/spec/v2.0.0.html or https://calver.org/
or simple increasing integers, or ?
Frontend-version of objects that are parts of the app-hierarchy/tree.
Type for an Node in the app tree.
Connection factory builder for ActiveMQ Artemis (Jakarta client).
Broker adapter for ActiveMQ Artemis: runs the queue's QueueControl MBean
operations through the web console's Jolokia API (POSTs under
/console/jolokia/ on the provider's managementUrl - e.g.,
http://host:8161).
marker for an object which can be processed by the QInstanceAssessor.
Internal structural values for associated writes and their permission preflight.
Only this helper constructs backend requests; no generic security-bypass flag
or caller-supplied filter is accepted by this operation.
Snapshot values without rejecting explicit nulls or mutating caller records.
Only declared parent relationships can construct this exact-key projection.
Private old and prospective relationship tuples for replacement updates.
Private snapshots, with the fields that were not supplied by the caller.
The definition of one of a table's associated scripts (a field of the
table that references a script of a given type).
Preflight the association writes requested by HTTP before changing the parent.
Association write permission checks for the HTTP write routes.
definition of a qqq table that is "associated" with another table, e.g.,
managed along with it - such as child-records under a parent record.
A named association and its join, without recursive child table metadata.
A declared association's field pairs, oriented from parent to child.
Interface to be implemented (as lambdas), for working with AsyncJobManager.
Argument passed to an AsyncJob when it runs, which can be used to communicate
data back out of the job.
Class to manage running asynchronous actions, and working with their statuses.
Possible states for an async job's "running"-ness.
Object to track current status of an async job - e.g., its state, and some
messages from the backend like "x of y"
Class that knows how to Run an asynchronous job (lambda, supplier) that writes into a
RecordPipe, with another lambda (consumer) that consumes records from the pipe.
block that plays an audio file
Insert 1 or more audits (and optionally their children, auditDetails)
Takes care of managing the foreign key tables (auditTable, auditUser).
Interface for classes that can be added to QInstance for customizing the
AuditAction.Object to accumulate multiple audit-details to be recorded under a single
audit per-record, within a process step.
Protect audit table egress using the policy of the table whose data changed.
Executor for audit handlers.
Policy for how audit handler failures should be treated.
Base interface for audit handlers that can receive audit events.
Type of audit handler - determines which hook point it receives events from.
Input object for the audit action - an object which contains a list of "single"
audit inputs - e.g., the data needed to insert 1 audit.
Records key destruction without modifying previously sealed audit rows.
Input data to insert a single audit record (with optional child record)..
MetaData provider for the QQQ audit system tables.
One protector per instance.
Application hook for audit tokens and effective classification.
Meta-data to provide details of an Auth0 Authentication module
QQQ AuthenticationModule for working with Auth0.
Utility class for resolving the appropriate authentication provider for
a request based on its scope.
Context information for resolving the appropriate authentication provider
for a request.
Represents a scope for authentication provider registration.
API-specific authentication scope - applies to requests for a specific API.
Instance default authentication scope - applies to all requests unless
overridden by a more specific scope.
Route provider-specific authentication scope - applies to requests handled
by a specific route provider (e.g., an SPA).
enum of possible values for a record's Automation Status.
Table-automation meta-data to define how this table's per-record automation
status is tracked.
Enum of possible types of per-table, per-record automation-status tracking.
Key provider that reads base64 keys from AWS Secrets Manager, through
SecretsManagerUtils (so it uses the same SECRETS_MANAGER_* environment
configuration).
Validate a provider's signed logout event before modifying stored OAuth2 sessions.
Input for the OIDC back-channel logout endpoint.
Output interface for the OIDC back-channel logout endpoint.
Response for the OIDC back-channel logout endpoint.
Endpoint spec for OIDC Back-Channel Logout.
interface for an "adapter" class that implements a
FieldFunction for a
particular backend (QBackendModuleInterface).Registry of
BackendFieldFunctionAdapterInterface implementations, keyed
by function type identifier name.Utility class for backend modules that need to do filter operations.
Simple interface that Backend Steps (e.g., code within processes) must implement
Optional hook on RunProcessInput, called by RunProcessAction after each
backend step finishes successfully (after its state is stored).
Subclass of RunBackendStepInput, meant for use in the postRun of the transform/load
steps of a Streamed-ETL-with-frontend processes - where the Record list is not the
full process's record list - rather - is just a preview (e.g., first n).
Subclass of RunBackendStepOutput, meant for use in the pseudo-steps used by
the Streamed-ETL-with-frontend processes - where the Record list is not the
full process's record list - rather - is just a preview of the records - e.g.,
the first n.
Configs for how a backend that uses variants works.
interface to be implemented by enums (presumably) that define the possible
settings a particular backend type can get from a variant record.
Utility methods for backends working with Variants.
Record error message for when some bad input caused the issue (e.g., a missing
value, or an illegal value).
element of BrandingMetaData - content to send to a frontend for showing a
user across the whole UI - e.g., what environment you're in, or a message
about your account - site announcements, etc.
interface to define keys for where banners should be displayed.
Base class for utility functions that make up the unique ways in which an
API can be implemented.
enum of which HTTP Method the backend uses for Updates.
Basic version of a C3P0 Connection Customizer used by QQQ - that does things
expected for an RDBMS backend - specifically:
- runs queriesForNewConnections, if they are set.
Class for storing all basepull configuration data
marker - used to indicate that a step is meant to be used for basepull extracts.
instance validator plugin, to ensure that a process which is a basepull uses
an extract step marked for basepulls.
Base class for "query" (e.g., read-operations) action interfaces (query, count, aggregate).
Note that much of this class came from the old (old) QueryManager class.
Base class for the StreamedETL preview invalid input: '&' execute steps
an implementation of a TableCustomizer that runs a subclass of
AbstractRecordSyncToScheduledJobProcess - to manage scheduledJob records that
correspond to records in another table (e.g., a job for each Client)
Easiest way to use is:
- BaseSyncToScheduledJobTableCustomizer.setTableCustomizers(tableMetaData, new YourSyncScheduledJobProcessSubclass());
which adds post-insert, -update, and -delete customizers to your table.
Basic health indicator that just reports UP always.
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.
BackendStep for performing the Cleanup step of a basic ETL process - e.g.,
after the loading, delete or move the processed file(s).
BackendStep for collecting the file names that were discovered in the
Extract step.
Function body for performing the Extract step of a basic ETL process.
Function body for performing the Load step of a basic ETL process.
Definition for Basic ETL process.
Function body for performing the Extract step of a basic ETL process.
Basic definition of an operation (e.g., an endpoint exposed in the API).
Basic version of a response from a spec/endpoint.
Definition for Basic process to run a report.
Basic implementation of interface for identifying schedulable things
BigDecimal version of data aggregator
A link used within a (widget) block.
marker-interface for classes (enums, actually) used to define the "slots"
within a widget-block that can have links or tooltips applied to them.
Marker interface for classes that define the "styles" that can be customized
within a particular widget-block type.
A tooltip used within a (widget) block.
Marker interface for classes that define the values that can be returned for
a particular widget-block type.
Version of excel styler that does bold headers and footers, with basic borders.
Version of POI excel styler that does bold headers and footers, with basic borders.
Application identity (names, images, accent colors and banners) for a frontend.
Public, fixed-role access to the images already declared in public branding.
A banner message shown in one of the frontend's banner slots.
Subclass of RecordPipe, which uses a buffer in the addRecord method, to avoid
sending single-records at a time through postRecordActions and to consumers.
Implementation of a code execution logger that builds a scriptLog and 0 or more
scriptLogLine records - but doesn't insert them.
Built-in ownership view.
Load step for bulk-delete.
Transform step for generic table bulk-insert ETL process
Load step for generic table bulk-edit ETL process
Transform step for generic table bulk-edit ETL process
Extract step for generic table bulk-insert ETL process
This step does a little bit of transforming, actually - taking rows from
an uploaded file, and potentially merging them (for child-table use-cases)
and applying the "Mapping" - to put fully built records into the pipe for the
Transform step.
step before the upload screen, to prepare dynamic help-text for user.
Transform step for generic table bulk-insert AND bulk-edit-via-file ETL process.
The AI provider route of the caller, from the X-QQQ-AI-Route header the
assistant's invoker sets (never the model).
Assisted bulk load (design spec #1171 sections 3.2 and 3.3): stateless
operations over an uploaded file, keyed by its upload ref, run as the
current session's user
The results of the assisted bulk-load operations (
BulkLoadAssist).One column of an upload: its shape, and sample values only where allowed.
A file column (index and header).
A table field (name, label, possible value source if any).
An error group: the file rows, the field when known, the error type and a
message (masked for classified fields on a STANDARD route).
A suggested mapping, with what it leaves unmapped and what needs value
mapping.
One line of the standard process summary.
An upload's header guess and column profiles.
A dry run's result.
One column of an uploaded file: its shape, and sample values only where allowed.
A file column.
A table field.
A row of values, e.g., from a file, for bulk-load
Given a bulk-upload, create a suggested mapping
Specialized error for records, for bulk-load use-cases, where we want to
report back info to the user about the field invalid input: '&' value.
this is the model of a saved bulk load profile - which is what passes back
and forth with the frontend.
Utility methods for working with records in a bulk-load.
An error group of a bulk-load dry run.
Runs BulkLoadAssist.suggestMapping: core's suggester over an upload's header row.
Input for POST /bulkLoad/{tableName}/suggestMapping.
Output of the assisted bulk-load operation (filled from core's result).
A suggested mapping for an upload's header row.
POST /bulkLoad/{tableName}/suggestMapping: core's suggested bulk load
profile for an uploaded file's header row (assisted bulk load, design spec
#1171 section 3.2).
A line of the bulk-insert process summary.
utility to build BulkLoadTableStructure objects for a QQQ Table.
Runs BulkLoadAssist.profile: the header guess and column profiles of an upload (samples only where the PHI rule allows).
Input for GET /bulkLoad/uploads/{uploadRef}/profile.
Output of the assisted bulk-load operation (filled from core's result).
The header guess and column profiles of an upload.
GET /bulkLoad/uploads/{uploadRef}/profile: the header guess and column
profiles of an uploaded file, for a target table (assisted bulk load,
design spec #1171 section 3.2).
Where the assisted bulk-load operations read an uploaded file from, by its
opaque upload ref, as the current session's user.
The registered
BulkLoadUploadSource (one per server).Runs BulkLoadAssist.validate: a dry run of a profile through the table's bulk-insert process (nothing is stored).
Input for POST /bulkLoad/{tableName}/validate.
Output of the assisted bulk-load operation (filled from core's result).
The result of a bulk-load dry run (nothing is stored).
POST /bulkLoad/{tableName}/validate: a dry run of a bulk load profile over
an uploaded file, through the table's real bulk-insert process, stopping
before anything is stored (assisted bulk load, design spec #1171 section
3.2).
Specialized error for records, for bulk-load use-cases, where we want to
report back info to the user about the field invalid input: '&' value.
a button (for a process - not sure yet what this could do in a standalone
widget?)
Meta-data, to assign to a table which is a "cache of" another table.
Action handler for running the cancel step of a qqq process
Things that can be done to tables, fields.
record containing the values managed by QContext.
Mode for filesystem backends: are all records in a single file, or are there
many files?
Field behavior that changes the case of string values.
Version of map where string keys are handled case-insensitively.
Model containing datastructure expected by frontend bar chart widget
Standard/re-usable post-insert customizer, for the use case where, when we
do an insert into table "parent", we want a record automatically inserted into
table "child".
value that goes inside a QMetadataProducingEntity annotation, to control
the generation of a QJoinMetaData
Generic meta-data-producer, which should be instantiated (e.g., by
MetaDataProducer Helper), to produce a QJoinMetaData, based on a
QRecordEntity and a ChildTable sub-annotation.
Model containing data structure expected by frontend ChildRecordList widget
See
ChildRecordListRenderer.Builder for definitions of several properties
in here.Generic widget-renderer for display a list of child records.
value that goes inside a QMetadataProducingEntity annotation, to control
the generation of a QWidgetMetaData - for a ChildRecordList widget.
Generic meta-data-producer, which should be instantiated (e.g., by
MetaDataProducer Helper), to produce a ChildRecordList QWidgetMetaData, to
produce a QJoinMetaData, based on a QRecordEntity and a ChildTable sub-annotation.
value that goes inside a QMetadataProducingEntity annotation, to define
child-tables, e.g., for producing joins and childRecordList widgets
What a running chunk can see and do: its job and chunk rows, its lease, the
fenced checkpoint write, and the cooperative check (pause, cancel, drain,
lost lease) that plans call at safe points - between pages or steps.
The CHUNKED plan for streamed ETL processes (spec section 2.4, plan 1): bulk
insert, edit and delete, record actions and data processes.
What a chunk run produced.
Status of one chunk of a durable job (jobs_chunk.status).
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.
Supplies instance keys and optional per-record, per-field shreddable keys.
Key bytes and the public identifier stored in a token.
One key source per instance.
Classification-based protection for noninteractive output, independent of user tier.
Shared, versioned audit/email value tokens.
Utilities for reading classes - e.g., finding all in a package
Client channels: which clients (Next UI, the AI assistant, a CLI...) may
call the UI API, and which objects are always denied to a channel, whatever
the human user's permissions
meta-data class to represent collapsible sections in a layout.
A log message, which can be "collected" by the QCollectingLogger.
Utility class for working with Collections.
Utility for verifying that the ColumnStats process works for all fields,
on all tables, and all exposed joins.
This is a single-step process used to provide Column Statistics.
Object with properties to allow configuring behavior of the ColumnStats
process.
Extension of a BasicOperation that adds the full openAPI Method object.
Data used to render a Composite Widget - e.g., a collection of blocks
Runs an atomic conditional (compare-and-set) update against a table's backend.
Input for a ConditionalUpdateAction: set
values on the rows of the
table that match filter, atomically.Backend capability CONDITIONAL_UPDATE: an atomic compare-and-set update.
Version of AbstractQQQApplication that assumes all meta-data is defined in
config files (yaml, json, etc) under a given directory path.
Class to manage access to JDBC Connections.
Settings for a connection pool (if your backend is configured to use one).
interface for classes that can provide jdbc Connections for an RDBMS backend.
What a consistent-read transaction actually guarantees - to be recorded by
callers (e.g., in a backup manifest) rather than assumed.
How far apart in time a consistent-read transaction allows the reads of
different tables in the same backend to be.
Input for QBackendModuleInterface.openConsistentReadTransaction - asks a
backend for a read-only transaction through which every table read reflects
one instant (see ConsistencyScope).
Result of RDBMSActionStrategyInterface.beginConsistentRead - what the
connection's transaction now guarantees, and (if the database can share it)
an id by which other connections can attach to the same snapshot.
Shared dependency discovery for forms, bulk edit and write validation.
Action to convert a string of HTML to a PDF!
The default AiDataGateway: the core actions, in-process, with the session in
QContext (inputs prepared by AiToolContext, so permissions are enforced).
Permission enforcement inside the core actions (issues #1061 and #1062).
AutoCloseable handle on an authorized action scope.
Action to run a count against a table.
Hash that provides "counting" capability -- keys map to Integers that
are automatically/easily summed to
Input data for the Count action
Interface for the Count action.
Output for a count action
count_records: the number of records of a readable table matching a filter
(METADATA_ONLY fields may be filtered on) - plus a "count" render payload
with an openHref to the filtered list.
Execution context for virtual criteria and search expansion.
Possible behaviors for doing interpretValues on a filter, and a criteria
has a variable value (either as a string-that-looks-like-a-variable,
as in ${input.foreignId} for a PVS filter, or a FilterVariableExpression),
and a value for that variable isn't available.
class to give a human-friendly descriptive string from a cron expression.
Field Display Behavior class for customizing the display values used
in cron expression fields
Field display behavior, to add a human-redable tooltip to cron-expressions.
Model containing data required for a cron UI widget
Model containing data required for a cron UI widget
Widget for editing cron expression and timeZone (if used) fields
CSV export format implementation
Adapter class to convert a CSV string into a list of QRecords.
Session-relative user id.
Resolve session values before backend-specific null and comparison semantics.
For special cases of applying permissions, an application can implement a
custom permission checker via this interface - and place it on a table, process,
report, app, or widget via
QPermissionRules.withCustomPermissionChecker(QCodeReference).interface to be implemented by one that wishes to execute custom table triggers
Health indicator that checks database connectivity and connection pool health.
Data sensitivity, ordered from least to most sensitive.
Interface for customizer on a QReportDataSource's query.
Aggregate analysis metadata.
Aggregate analysis metadata.
Field Display Behavior class for customizing the display values used
in date-time fields
Enum to define various "levels" of group-by for on dashboards that want to
group records by, e.g., year, or month, or week, or day, or hour.
Meta Data Producer for DayOfWeek.
Conservative default redaction for credentials and common personal identifiers.
a default implementation of MetaDataActionCustomizerInterface, that is all noop.
Default implementation of RouteProviderContextHandlerInterface.
Action to delete 1 or more records.
Input for a Delete action.
Interface for the Delete action.
Output for a delete action
Process used by the delete bulkLoadProfile dialog
Process used by the delete view dialog
DeleteSharedRecord: {tableName; recordId; shareId;}
describe_table: one readable table's fields (only those exposed - NONE
fields are omitted; METADATA_ONLY / MASKED ones are flagged), help text,
descriptions and the user's permissions.
Utility methods to help with deserializing JSON streams into QQQ models.
How much of an alert an external channel (email, chat, paging, webhook) may
include.
One panel on a record's developer view, contributed by a
DeveloperPanelProviderInterface (e.g., the ESB, quick search, or SQL
workbench qbits).A process the frontend may launch for the record, in an ACTIONS
DeveloperPanelBlock.One generic block of content in a
DeveloperPanel.Kinds of
DeveloperPanelBlock - see that class for which fields each
kind uses.What a
DeveloperPanelProviderInterface builds its panel for: a
table, and (on a record's developer view) the record - already loaded under
the current user's permissions and record security locks.A label/value pair in a KEY_VALUES
DeveloperPanelBlock.A link in a LINKS
DeveloperPanelBlock.Contributes a panel to a record's developer view.
Build the developer panels for a table's record: the built-in panels
(record security), then every provider registered in the instance's
DeveloperPanelsMetaData, each asked whether it is available first.Instance-level registry of the
DeveloperPanelProviderInterfaces
that contribute panels to records' developer views.Tone of a developer panel's status badge or of a TEXT block.
Health indicator that checks available disk space.
Subclass of record pipe that ony allows through distinct records, based on
the set of fields specified in the constructor as a uniqueKey.
Model containing datastructure expected by frontend divider widget
Generic widget for showing a divider
Audit for a standard DML (Data Manipulation Language) activity - e.g.,
insert, edit, or delete.
Enumeration of DML operation types that can be audited.
Input for DML-level audit handlers containing full record snapshots.
DML operation type
Handler interface for receiving raw DML audit events with full record snapshots.
Input object for the DML audit action.
Output object for the DML audit action.
custom code that can run when user downloads a file.
specialization of bad-input status message, specifically for the case of
a duplicated key (e.g., unique-key validation error)
"Automatically" (spec section 2.4): when an eligible streamed ETL process
reaches its execute step with more rows than durableThresholdRows (default
1,000), or is alwaysDurable, the execute step is not run inline: the process
is launched as a durable job with the values collected so far, and the step
returns at once with the value
durableJobId and a summary line that
says the work is running in the background.The durable jobs facade: launch any eligible process as a job, control it,
and read its status.
Instance-level settings for durable jobs (QInstance supplemental meta data
named "durableJobs").
Defines the durable-jobs tables (jobs_job, jobs_chunk, jobs_row_error,
jobs_event, jobs_worker), their possible-value sources, joins, the record
lock, and the job control processes.
The per-pod durable jobs runtime: worker threads that claim and run chunks,
a heartbeat per running chunk (every ttl/3), the lease reaper (every pod,
every reaperIntervalSeconds), stall detection, and graceful drain.
Puts the durable-jobs security keys into a session: jobs_user = the user's id,
plus jobs_user_all_access for sessions holding the jobs_admin permission.
Names shared by the durable-jobs kernel: tables, security keys, permissions
and defaults.
The durable job store, over the jobs_* tables, on any backend with the
CONDITIONAL_UPDATE capability.
Per-process durable-job settings (supplemental process meta data "durable").
Table settings for deduplicating file rows loaded by a durable job.
Field behavior that sets a default value for a field dynamically.
EditSharedRecord: {tableName; recordId; shareId; scopeId;}
Delivers outbox effects (spec section 2.13): claims due effects with leases,
calls their targets as the system user, and records the outcome, fenced on
the lease.
A test seam: called around a delivery (the fault-injection tests halt the
JVM there).
The deterministic idempotency key of an effect, and the forms targets need
(spec section 2.13): jobId:chunkSeq:rowKey:effectName.
A dispatcher's hold on one effect while it delivers or reconciles it.
One effect, as handed to its target for delivery or reconciliation.
What a target's delivery attempt achieved
The four outcomes.
Status of one outbox effect (jobs_effect.status).
The jobs_effect outbox: write effects with a chunk's progress, claim due
effects (FOR UPDATE SKIP LOCKED where supported, else conditional updates),
record outcomes (fenced), and reap leases of dispatchers that died.
Counts of a job's effects.
A system outside the job's database that receives effects (email, an HTTP
API, object storage, another database).
Resolve registered effect targets (DurableJobsMetaData.effectTargets) to
instances, one per code reference.
for use-cases where a metaDataProducer directly adds its objects to the
qInstance, then this empty object can be returned.
generic middleware input that has no fields.
Backend module for a table based on a java enum.
Key provider that reads base64 keys from environment variables - which is
how Infisical-via-ESO and Kubernetes secrets arrive.
The ESB app: one overview widget, for users with esbView.hasAccess (the
ESB's service-level permission).
Queue management through a broker's management API (spec section 8): queue
depth and consumer counts, and actions on the broker's queues - including
dead-letter queues and topic subscription queues, which are queues on the
broker too (see EsbBrokerNames).
Picks the broker adapter for an ESB provider.
The broker queue management actions (spec section 8) that a provider's
broker supports - so the UI shows, and the operate processes allow, only
those
The broker-side names of queues that brokers make for QQQ - so they can be
browsed and managed like any other queue.
A message on a broker queue, as browsing shows it (the messages endpoints'
message shape):
- messageId: the JMS message id (what deleteMessages and moveMessages take)
The id of the ESB event that caused the work running on the current thread.
Broker-specific JMS setup for one EsbProviderType: builds the provider's
ConnectionFactory, and makes the broker's flavor of sessions and queues.
Long-lived JMS connections to ESB providers (brokers): one connection per
provider, shared by every session opened on it.
One exclusive publication.
A runtime's listener on the ESB control topic (spec section 6): the internal,
non-durable topic qqq.esb.control, on each provider that the runtime's
triggers use.
What a control message asks each node to do to its runner for a trigger.
A point-in-time copy of one destination's or trigger's counters on this node
(spec section 7).
What a trigger does with a message that has failed maxAttempts times: send it
to its dead-letter queue, or discard it.
GET /esb/deadLetters/{trigger} - Dead letters of a trigger
Metadata producer for esbDeleteMessages.
Backend step for this process.
Turns ESB destination meta-data (or a broker-side queue name) into a JMS
Destination, in the flavor of one provider's broker.
Kinds of ESB destinations: a QUEUE (each message to one consumer) or a TOPIC
(each message to every subscription).
Developer panel for a record of a table that publishes change events to the
ESB: the CloudEvents type, source and subject of its events, where they are
published, the triggers (processes) subscribed to them with their dead
letter counts, and a sample event for this record.
Registers the ESB's record developer panel (
EsbDeveloperPanelProvider)
in the instance's developer panels.An ESB message: a CloudEvents 1.0 event (spec section 4)
Reads and writes EsbEvents as CloudEvents 1.0 structured JSON (spec section
4), and as JMS TextMessages.
Makes the EsbEvents that QQQ publishes (spec section 4).
Register passive connection checks and read-only broker management checks.
Instance-level ESB meta-data: the providers (brokers) and destinations
(queues and topics) that tables and processes publish to and trigger from,
and the instance name that identifies this application in the source of the
events it publishes.
Registers the ESB endpoints (/qqq/v1/esb/...) as an extension of the UI API:
endpoint specs, served by the middleware version and described in its
OpenAPI document (QRun-IO/qqq docs/UI-API-EXTENSIONS.md).
Browses the messages on a broker queue (including dead-letter and topic
subscription queues) with a JMS QueueBrowser - so on every broker, with or
without a management API.
GET /esb/messages/{destination} - Messages on a destination
Metadata producer for esbMoveMessages.
Backend step for this process.
Shared metadata shape for the nine ESB management processes.
Server-side permission boundary and implementation for ESB operations.
GET /esb/overview - ESB overview
The ESB app's overview widget, of type ESB_OVERVIEW - which the frontend
renders from the overview endpoint (GET /qqq/v1/esb/overview).
Renderer for the ESB overview widget.
Widget data for the ESB overview widget: its type, and nothing else.
Metadata producer for esbPauseQueue.
Backend step for this process.
Metadata producer for esbPauseTrigger.
Backend step for this process.
Process lifecycle events that a process can publish to ESB destinations.
Publishes process lifecycle events (spec sections 4 and 5) - started,
completed, failed - to the destinations of the process's ESB publications
(EsbProcessMetaData) that list the event.
Process-level ESB meta-data: the destinations a process publishes its
lifecycle events to, and the triggers (queues and topics) that run it.
A process's publication to an ESB destination: which lifecycle events
(started, completed, failed) are published there.
GET /esb/process/{process} - ESB of a process
Types of message brokers supported by the ESB.
Explicitly publish one event, with a caller-supplied type and data, to an ESB
destination (spec section 5) - callable from any process step or other code.
Sends ESB events to a destination (spec section 5): one PERSISTENT JMS
TextMessage per event, all on one session.
Input for EsbPublishAction: the destination (its QQQ name) to publish one
event to, the event's type (required, e.g., com.example.order.shipped), and
its data (optional; none means empty).
The result of publishing ESB events (EsbPublisher, EsbPublishAction):
whether they were sent, how many, and - when they weren't - why.
Metadata producer for esbPurgeQueue.
Backend step for this process.
A broker queue's state, from the broker's management API, at the moment it
was asked
Non-durable, non-shared topic fan-out using the ESB provider connection manager.
Publishes table record change events (spec sections 4 and 5) to the
destinations of the table's ESB publications (EsbTableMetaData) that list the
change's event.
Metadata producer for esbReplayDeadLetters.
Backend step for this process.
Metadata producer for esbRestartTrigger.
Backend step for this process.
Metadata producer for esbResumeQueue.
Backend step for this process.
Metadata producer for esbResumeTrigger.
Backend step for this process.
The runtime service (QInstance.withRuntimeService) through which an
application launcher starts the node's ESB trigger runtime
(QEsbRuntime.getInstance) with its server, and stops it at shutdown.
Shared pieces of the ESB UI API specs (QRun-IO/qqq docs/UI-API-EXTENSIONS.md):
the input (which body to build, from what parameters), the executor (runs
EsbStatusBuilder with the session in context), the response (the built
body, written with nulls kept), and the base spec.
base of the ESB specs: secured, tagged, JSON written with nulls kept (as
the route provider before them did), success schema per operation.
Builds one operation's body from an EsbStatusBuilder.
executor: build the body with the session the spec set up
input: the body builder bound to the request's parameters
output interface
response: the body EsbStatusBuilder built (its schema is per operation)
OpenAPI tag of the ESB operations.
In-memory ESB counters for this node (spec section 7): nothing is stored, and
counts start over when the app restarts.
Builds the bodies of the ESB endpoints (see the specs in the specs package), as maps in
exactly the shape of the endpoint contract, from the QContext's instance and
session: ESB meta-data, this node's counters (EsbStats) and trigger states
(QEsbRuntime), and broker data from the management API when a provider has
a managementUrl.
Record change events that a table can publish to ESB destinations.
Table-level ESB meta-data: the destinations a table publishes its record
change events to.
A table's publication to an ESB destination: which record change events
(insert, update, delete) are published there.
GET /esb/table/{table} - ESB of a table
A trigger that runs a process from messages on an ESB queue or topic.
Pause, resume, or restart a trigger's consumers on every node (spec sections
6 and 8).
Runs a trigger's process for ESB events (spec section 6), plus the per-message
helpers that EsbTriggerRunner uses around a run: the attempt number, backoff,
error text, and dead-letter messages.
How a trigger runs its process: SINGLE = one message per run; BATCH = up to
batchSize messages (or what arrives within batchWaitMs) per run.
Runs one trigger's consumers on this node (spec section 6).
The state of one trigger's consumers on this node (EsbTriggerRunner.getState)
OpenAPI component schemas of the ESB UI API responses (the shapes
EsbStatusBuilder produces).
Thrown by EsbEventCodec when a message isn't a CloudEvents 1.0 JSON event
that QQQ can read: not a JMS TextMessage, not a JSON object, missing or
invalid attributes, or data that isn't a JSON object.
Excel export format implementation - built using fastexcel library
Excel export format implementation using POI library, but with modifications
to actually stream output rather than use any temp files.
style customization points for Excel files generated via our streaming POI.
Utility class for working with exceptions.
Action to execute user/runtime defined code.
Process step to execute a report.
Action to generate an export from a table
At this time (future may change?)
Input for an Export action
Output for an Export action
Utility for verifying that the ExportAction works for all tables, and all
exposed joins.
Interface for various export formats to implement.
interface for classes that can be used to customize visual style aspects of
exports/reports.
Version of ExtractViaQueryStep that knows how to set up a basepull query.
Generic implementation of an ExtractStep - that runs a Query action for a
specified table.
The failed rows of a job (spec section 2.7):
- retry them as a child job (ROW_SET) over just those rows, with the same
inputs or a corrected bulk-load profile; the row errors get retryJobId;
- download them as CSV (the original columns plus an error column) to fix
in a spreadsheet and load again.
Interface for classes that know how to apply styles to an Excel stream being
built by fastexcel.
How a permission-bearing record feature is granted.
A channel-specific ceiling, combined with locks and the instance resolver.
A resolver decision; the reason must never contain a field value.
Value-free audit notification.
Kinds of field access reported to the resolver.
Single entry point for field policy, enforcement, masking and audit notifications.
Per-invocation exact searches, completed only by the action that enforced them.
Outcome of an exact-match search.
Session-aware policy, reveal grants and value-free access notifications.
One resolver per instance.
Effective field access, ordered from least to most restrictive.
Special fancy things that fields might do in UIs.
Wrapper (record) that holds a QFieldMetaData and a QTableMetaData -
With a factory method (`get()`) to go from the use-case of, a String that's
"joinTable.fieldName" or "fieldName" to the pair.
Runtime custom field metadata and storage.
Interface for (expected to be?)
Marker interface for a field behavior which you might want to send to a
frontend (e.g., so it can edit values to match what'll happen in the backend).
Interface to mark a field behavior as one to be used during generating
display values.
a default implementation for this behavior type, which does nothing.
Interface to mark a field behavior as one to be used before a query filter
is executed.
Application of a Function to a field - e.g., to take its raw or pure value
as stored in the backend, and apply a function to it (as in the math sense),
to get out a different value.
Custom jackson deserializer, to deal w/ mapping a functionTypeIdentity
to a FieldFunctionType object
Singleton registry that auto-discovers all
FieldFunctionType implementations
on the classpath and maps their identifier names to FieldFunctionTypeIdentifier
objects.Describes a single parameter accepted by a
FieldFunctionType.Interface defining a type of function that can be applied to a field in a
QQQ query or virtual field expression.
Marker interface for objects that uniquely identify a
FieldFunctionType.QInstance-level registry of
FieldFunctionType instances.Presentation rules for a restricted value.
Enum values for the string wire representation.
Define, for a field, a lock that controls if users can or cannot see the field.
Compatibility facade for field locks; enforcement is owned by FieldAccessHelper.
Model containing data structure expected by frontend FieldValueListData widget
Masks values of fields whose exposure is MASKED:
- email addresses keep their first character and their domain (j***@example.com)
- numbers, and strings of digits (and separators), keep their last 4 digits (***1234)
- other strings keep their first and last character (a***z), or are fully
masked (***) when 4 or fewer characters long.
(local) Filesystem backend meta data.
QQQ Backend module for working with (local) Filesystems.
Interface to add additional functionality commonly among the various filesystem
module implementations.
Checked exception to be thrown from actions within this module.
Class to serve as a template for producing an instance of a process invalid input: '&' tables
that provide the QQQ service to manage importing files (e.g., partner feeds on S3).
Process MetaData Builder for FilesystemImporter process.
BackendStep for FilesystemImporter process
Job is to:
- foreach file in the `source` table (e.g., a ONE-type filesystem table):
- optionally create an archive/backup copy of the file
- create a record in the `importFile` table
- parse the file, creating many records in the `importRecord` table
- remove the file from the `source` (if so configured (e.g., may turn off for Read-only FS))
Define the field names (keys) to be used in the backendDetails structure
under Records from this (these) modules.
(mass, streamed) storage action for filesystem module
Definition for Filesystem sync process.
BackendStep to sync two filesystem tables (copying the new files to a 3rd
location as well...)
(local) Filesystem specific Extension of QTableBackendDetails
Builder class to create standard style QTableMetaData for tables in filesystem
modules (avoid some boilerplate).
Model containing datastructure expected by frontend filter and columns setup widget
Display value formatter for fields which store a QQueryFilter as JSON.
Interface where we can associate behaviors with various use cases for
QQueryFilters - the original being, how to handle (in the interpretValues
method) how to handle missing input values.
Utility to help query action validate the fieldNames in a filter.
Alternative list-builder pattern (vs.
Events for which a record follower may want notifications.
Helper for Generating reports - to interpret formulas in report columns,
that are in "excel-style", ala: =MINUS(47,42) or
=IF(LT(ADD(${input.x},${input.y}),10,Yes,No)
An authentication module with no actual backing system - all users are treated
as anonymous, and all sessions are always valid.
Create a garbage collector process for a given table.
Executor for the general file download endpoint.
Input for the general file download endpoint.
Output interface for the general file download endpoint.
Response wrapper for the general file download endpoint.
Spec for the general file download endpoint (GET /download/{file}).
Utility methods for working with QQQ records and table actions inside user -
defined QQQ processes steps.
Action to generate a report.
Action to run a get against a table.
MetaDataProducer and BackendStep for GetAuditsForRecordProcess
Input data for the Get action
Interface for the Get action.
Output for a Get action
get_record_history: the audit history of one record.
get_record: one record of a readable table, by primary key, read as the
current user (so record security applies: a record the user can't see is
NOT_FOUND, exactly like a missing one) - only exposed field values.
GetSharedRecords: {tableName; recordId;} => [{id; audienceType; audienceId; audienceLabel; scopeId}]
For a given table (name) and API version, return the list of fields that apply
for the API.
Aggregate analysis metadata.
Process to find records with a bad automation status, and repair them.
HealthCategory
A bounded health probe.
Executor that runs health indicators and aggregates results.
HealthCheckInput
HealthCheckKind
HealthCheckMetaData
MetaData for health check configuration.
HealthCheckOutcome
Result of executing a single health indicator check.
Static and dynamic checks.
Resolve a dynamic set of checks from application configuration.
HealthCheckSupplierMetaData
Merge code-owned identity without overwriting operator scheduling overrides.
GET /health/components/{name}.
Flat typed details.
GET /health/checks/{name}/history.
Interface for components that can perform health checks.
Compatibility boundary for existing application indicators.
Core-owned, independently versioned health UI API extension.
A standard small line chart on each check record, using recorded latencies.
The small chart uses the same data structure as the generic line chart.
MetaData producer for health check configuration.
Define the central health tables, alerts, core probes, action and app.
HealthMetric
Prometheus projection deliberately excludes all messages and details.
HealthMonitoringMetaData
Bounded probe execution shared across requests, including interrupt-ignoring
checks.
Conservative sanitization at the boundary between probes and health records.
Overall health check response containing the aggregate status and results
from all individual health indicators.
HealthResultStatus
Delete old history in bounded batches, preserving each check's last transition.
Standard streamed record action: preview counts only; load executes checks.
Preview and transform do not run checks; results accumulate during load.
Execution only: a transient runner is closed even when a check fails.
Slot-leased health execution.
POST /health/checks/{name}/run.
Own the health runner for the lifetime of its server or application launcher.
Generic scheduler lifecycle check, independent of scheduler implementation.
Round-trip a unique probe session without touching real user sessions.
Shared secured table projections.
HealthStatus
Deprecated, for removal: This API element is subject to removal in a future version.
GET /health/summary.
Pure threshold and flap evaluation; the runner persists and dispatches effects.
A decision contains only new state and alert intents, with no I/O.
HealthTriggeredBy
Generic dashboard widgets backed exclusively by persisted health records.
HelpBundle.
Framework-independent help coverage gate for core, qbits and host applications.
HelpBundleEntry.
Precedence of registered bundle layers.
Help table actions with standard review and result summary components.
Classpath help bundles in registration order, with deterministic precedence.
A help row's unique address.
Winning text and its provenance.
Three-way merge of raw bundle text and user edits, through audited table actions.
Counts describe planned/applied work; upstreamChanged includes pending review.
QRecord Entity for HelpContent table
HelpContentFormat - possible value enum
Stable three-way merge baseline for raw help text.
Meta-data provider for table invalid input: '&' PVS's for defining help-content for other
meta-data objects within a QQQ app
after records are inserted, put their help content in meta-data
after records are updated, put their help content in meta-data
remove existing helpContent from meta-data when a record is deleted
Record user authorship without replacing a bundle row's provenance.
in case a row's Key or Role was changed, remove existing helpContent from that key.
HelpContentRole - possible value enum
Provenance values for help content.
Scoped per-thread marker distinguishing sync writes from user edits.
Provenance values for help content.
Public help contract.
Per-session copies of help, with targeting enforced before transmission.
Authoring coverage, including hidden targets, gated by help author permissions.
HelpCoverageEntry data.
HelpCoverageEntryV1 contract.
HelpCoverageExecutor contract.
HelpCoverageInput data.
HelpCoverageMiddlewareInput contract.
HelpCoverageOutput data.
HelpCoverageResponseV1 contract.
HelpCoverageSpecV1 contract.
HelpCoverageTotal data.
HelpCoverageTotalV1 contract.
How a piece of help content is formatted.
Interface to be associated with a HelpContent, to identify where the content
is meant to be used (e.g., only on "write" screens, vs. on app home pages, etc).
Ranked help search shared by UI clients and the assistant.
HelpSearchExecutor contract.
HelpSearchInput data.
HelpSearchMiddlewareInput contract.
HelpSearchResponseV1 contract.
HelpSearchResult data.
HelpSearchResultV1 contract.
HelpSearchSpecV1 contract.
An addressable help target.
The canonical help addresses shared by search, coverage and data reload.
Resolve raw references at the server boundary, never in persisted help text.
Host or qbit setting lookup.
class to contain http api responses.
HTTP delivery with a stable provider idempotency key and conservative outcome reporting.
block to display an icon
block to display an image
Specialization of a QueryJoin, for when the join is added to the query,
not by the caller, but by the framework, because it is implicitly needed
to provide a security lock.
combine all unstructured fields of the record into a JSON blob in the "values" field.
an object which is intended to be constructed via a CodeReference, and,
moreso, after it is created, then the initialize method here gets called,
passing the codeRefernce in - e.g., to do additional initalization of the
object, e.g., properties in a QCodeReferenceWithProperties
Per-pod mirrors of already-running inline processes.
Synchronous fan-out on virtual threads; a failed listener never fails a write.
Singleton class that provides a (non-persistent!!)
block to display an input field - initially targeted at widgets-in-processes
interface to define input sources - idea being, so QQQ can have its standard
ones (see QInputSource), but applications can define their own as well.
Action to insert one or more records.
Input data for the Insert action
Interface for the Insert action.
Output for an insert action
InsertSharedRecord: {tableName; recordId; audienceType; audienceId; scopeId;}
Instant version of data aggregator
Integer version of data aggregator
Class-level annotation to declare what fields should run through the variable
interpreter - e.g., to be replaced with env-var values at run-time.
Example showing how to configure multiple SPAs using IsolatedSpaRouteProvider
This example demonstrates:
1.
Example Admin Authenticator
Example QQQ Application
Complete isolated SPA route provider with deep linking support.
Unauthenticated liveness, readiness and optional Prometheus routes.
Meta-data to define a Javalin route provider configuration.
Control actions on a durable job (spec section 2.7).
Jobs UI API v1 representation.
What a durable job chunk hands to the process steps it runs, on the thread
that runs them:
- a provided transaction: StreamedETLExecuteStep loads into it instead of
opening (and committing) its own, so the chunk's rows and its DONE mark
commit together (SAME_TRANSACTION: exactly once);
- a row-error sink: transform and load steps report each failed row (file
row number or record key, field, code, message) so the job can record
them in jobs_row_error.
Which job chunk this scope runs: the parts of an effect's idempotency key,
and the process whose effect declarations apply.
The chunk's cooperative check (pause, cancel, drain, lost lease), run
between pages; it throws JobInterruptedException to stop the chunk.
One failed row.
Picks the next chunk for this pod and claims it (spec section 2.8).
A provider of job-level side effects, such as delivering a job's outputs
(spec section 2.13).
Asks the registered JobCompletionEffects providers for a completing job's
job-level effects and writes them to the outbox.
The job control actions as record actions on jobs_job (spec section 2.7):
standard streamed-ETL processes with the usual Review and Result summary
lines, so every client runs them through the standard process API.
Result: apply the action to each job.
Review: which jobs the action applies to, and which are skipped.
Jobs UI API v1 representation.
A side effect a durable process's step causes, declared in its
DurableProcessMetaData (spec section 2.13): its name (unique in the process),
the step that emits it, the target that delivers it (external effects), and
its type.
Owner/admin record actions for resolving external effects through standard process tracing.
Resolve each effect after checking its job owner and re-reading its current state.
Review only effects that are neither already sent nor held by a dispatcher.
How a process step causes a side effect outside the job's database (spec
section 2.13).
How a step's side effect is made safe across crashes and reruns (spec
section 2.13).
Type of a durable job timeline event (jobs_event.type).
Moves a job to the status its chunks imply, once nothing is running:
CANCELLING -> CANCELLED, PAUSING -> PAUSED, and RUNNING (or QUEUED) with no
work left -> COMPLETED, COMPLETED_WITH_ERRORS, FAILED or NEEDS_REVIEW.
Exception thrown by AsyncJobManager, not to indicate an error, per se, but
rather to indicate that a job has taken too long, as is now "going async".
How safe it is to re-run a chunk (jobs_job.idempotency).
Thrown from a cooperative check to stop a chunk at a safe point: the job was
paused or cancelled, this pod is draining, or the lease was lost.
Why the chunk stopped.
A worker's lease on one chunk.
One job-level effect a JobCompletionEffects provider asks for.
Jobs UI API v1 representation.
Severity of a redacted job log line.
Counts and display text for job progress.
Jobs UI API v1 representation.
Only kernel system sessions may mutate job log records.
Additional application redaction, applied after the built-in rules.
One buffer/flusher per running chunk.
Whether a job validates only or executes (jobs_job.mode).
Counts and display text for job progress.
Phase lifecycle within an attempt.
Jobs UI API v1 representation.
How a job's work is split into chunks and how one chunk runs.
Chooses the plan for a job (spec section 2.4):
- streamed ETL whose extract is ExtractViaQueryStep, launched over a filter
or record ids: CHUNKED by key range (TABLE_FILTER / RECORD_IDS);
- streamed ETL whose extract is BulkInsertExtractStep, launched with an
upload: CHUNKED by file rows (STORAGE_FILE);
- retry of failed rows: CHUNKED over just those rows (ROW_SET);
- ATOMIC semantics, and every other process: the STEPS plan.
Shared reporting API for durable chunks and ordinary async process steps.
Existing async status calls report rich durable progress without process changes.
Progress changes owned by the kernel at reclaim and terminal transitions.
Attempt-local monotonic progress and a sixty-second sliding rate window.
Jobs UI API v1 representation.
Counts and display text for job progress.
Jobs UI API v1 representation.
Whether a job runs in chunks or all-or-nothing (jobs_job.semantics).
Identity for durable jobs (spec section 2.10, R5).
Authenticated jobs operations.
Invalid state transitions are mapped to HTTP 409 by the endpoint.
Everything a job tells the outside world: realtime events (job.status on
every change, job.progress throttled to one per second per job - counts
only, never row values), alerts (jobs.job-failed, jobs.job-stalled) and the
owner's completion notification.
Parsed jobs operation parameters.
Where the input of a job comes from (jobs_job.source_type).
The typed response selected by a jobs operation.
Jobs tray, detail, polling and actions, registered only with the jobs tables.
Status of a durable job (jobs_job.status).
Jobs UI API v1 representation.
Tracking jobs for work that no durable plan runs (for example an assistant
turn): a jobs_job row the owner sees in the Jobs tray, with the same live
progress and log as a durable job.
Jobs UI API v1 representation.
Authorize tables read through client-supplied joins, filters and ordering.
Represents the graph of table-to-table joins in a QQQ Instance, treating
each join as a non-directional edge between two tables.
Specification for (at least part of) how two tables join together - e.g.,
leftField = rightField.
Helper object used throughout query, count, aggregate, and reporting actions
to assemble the full set of joins needed for a query, manage table aliases,
and enforce record-level security.
Record pairing a resolved
QFieldMetaData with the table name or
alias from which it was resolved.Type for a QJoin
JSON export format implementation
Runtime custom field metadata and storage.
Reads bulk-load rows from JSON Lines (.jsonl): one {"rowNo": n, "values":
[...]} per line.
Runtime custom field metadata and storage.
Runtime custom field metadata and storage.
Adapter class to convert a JSON string into a QFieldMapping object
Adapter class to convert a JSON string into a list of QRecords.
Utility class for working with JSON.
Shared key handling: validating key ids and decoding base64 key text.
Read a table a page at a time using keyset ("seek") paging, rather than
skip/limit: each page is
Default scalar preferences provider using JSON-encoded values.
A request to run a process as a durable job (DurableJobs.launch, and the
body of POST /qqq/v1/processes/{processName}/jobs).
Thrown when a fenced chunk write finds that the lease is no longer held (it
expired and was reclaimed).
Model containing datastructure expected by frontend bar chart widget
List.of is "great", but annoying because it makes unmodifiable lists...
Hash that provides "listing" capability -- keys map to lists of values that
are automatically/easily added to
Report streamer implementation that just builds up a STATIC list of lists of strings.
list_tables: the tables the current user can read through the assistant
(visible, exposed, READ permission), sorted by name, with what else the user
may do to each.
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).
record that tracks a problem that was encountered when loading files.
Function body to take care of loading the initial records to be used by a
process.
Action to load the details necessary to test a script.
Generic implementation of a LoadStep - that runs a Delete action for a
specified table.
Generic implementation of a LoadStep - that runs Insert and/or Update
actions for the destination table - where the presence or absence of the
record's primaryKey field is the indicator for which to do.
Generic implementation of a LoadStep - that runs an Insert action for a
specified table.
Generic implementation of a LoadStep - that runs an Update action for a
specified table.
LocalDate version of data aggregator
Useful things to do on a mac, when doing development - that we can expect
may not exist in a prod or even CI environment.
Model containing datastructure expected by frontend location widget
Implementation of a code execution logger that logs to LOG 4j
The default alert sink, used when no alerts implementation is installed: it
logs.
Implementation of ProcessTracerInterface that writes messages to the Logger.
Executor for the logout endpoint.
Input for the logout endpoint.
Output interface for the logout endpoint.
Response for the logout endpoint.
Endpoint spec for logging out a session.
Application pattern redaction, applied to the completed message and string log values.
Long version of data aggregator
Map.of is "great", but annoying because it makes unmodifiable maps, and it
NPE's on nulls...
The settings a frontend may read from an instance's `materialDashboard`
supplemental meta-data.
The weekday criteria settings from an instance's `materialDashboard`
supplemental meta-data: whether query screens offer "day is any of" and
"day is none of" on date and date-time fields, and the arguments to send
with the WeekdayOfDateTime field function (e.g., a time zone).
Basic memoization functionality - with result timeouts (only when doing a get -
there's no cleanup thread), and max-size.
Object stored in the Memoization class.
In-memory version of aggregate action.
A simple (probably only valid for testing?)
In-memory conditional update (for tests and single-JVM use): atomic under the
memory store's per-table lock; the clock is this JVM's clock.
Consistent-read transaction for the memory backend: holds a copy of all the
data in the store, taken at one instant (under the store's lock), which the
memory query, count and aggregate actions read from when this is the
transaction on their input.
In-memory version of count action.
In-memory version of delete action.
Health indicator that checks JVM memory usage.
In-memory version of insert action.
since some settings are required for a variant, if you're using memory backend
with variants, this is a setting you can use.
In-memory version of query action.
Storage provider for the MemoryBackendModule
Opaque point-in-time copy of all the data in the store, as taken by
takeSnapshot - for use with callWithSnapshot.
implementation of bulk-storage interface, for the memory backend module.
In-memory version of update action.
Generic ETL Load step for a merge duplicates process.
Definition for Standard process to merge duplicate records in a table.
Optional features declared by a messaging provider.
Action to fetch top-level meta-data in a qqq instance.
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.
Interface to be implemented by classes that are designed to help customize
meta-data objects as they're being produced, e.g., such as a table produced
via the QMetaDataProducingEntity, or maybe tables loaded by a qbit??
noop version of this interface - used as default value in annotation
Input for the meta-data action
Loads application metadata, rejecting invalid input instead of partial success.
Output for a metaData action
Abstract class that knows how to produce meta data objects.
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.
Help work with MetaDataProducers.
Interface for classes that know how to produce meta data objects.
Output object for a MetaDataProducer, which contains multiple meta-data
objects.
Interface to mark objects that can be produced by a MetaDataProducer.
A set of endpoint specs that a module or qbit adds to the versioned UI API
(`/qqq/v1`), under one namespace.
The instance's registry of UI API extensions: endpoint specs that modules
and qbits add to the versioned UI API (`/qqq/v1`).
Version 1 of the QQQ UI API (`/qqq/v1`).
A Mock implementation of the QModuleInterface.
Mock implementation of a FunctionBody.
Mocked up version of query action.
Mocked up version of delete action.
Mocked up version of insert action.
Mocked up version of query action.
Mocked up version of update action.
The model APIs that expose a table, for the UI API's
GET /qqq/v1/table/{tableName}/apis (registered through
META-INF/services).
Wrapper around a MongoClient, ClientSession, and a boolean to help signal
where it was opened (e.g., so you know if you need to close it yourself, or
if it came from someone else (e.g., via an input transaction)).
Meta-data to provide details of a MongoDB backend (e.g., connection params)
QQQ Backend module for working with MongoDB
MongoDB transaction opened by MongoDBBackendModule.openConsistentReadTransaction -
wrapping a session that has snapshot read concern (if the server supports
it).
MongoDB-specific extension of BackendFieldFunctionAdapterInterface
for adapting a FieldFunction into MongoDB aggregation expressions.
Execute a Query action against a MongoDB backend.
MongoDB adapter for StringLengthFunction.
MongoDB adapter for SubStringFunction.
Extension of QTableBackendDetails, with details specific to a MongoDB table.
MongoDB implementation of backend transaction.
MongoDB adapter for WeekdayOfDateFunction.
MongoDB adapter for WeekdayOfDateTimeFunction.
Implementation of TableCustomizerInterface that runs multiple other customizers
Help you use a multi-level map, such as:
Map[String, Map[String, Integer]] countryStateCountMap = new HashMap[]();
Where you always want to put new maps at the lower-level if they aren't there,
and similarly, you want to start with a 0 for the value under each (final) key.
Subclass of RecordSecurityLock, for combining multiple locks using a boolean
(AND/OR) condition.
Model containing datastructure expected by frontend bar chart widget
Model containing datastructure expected by frontend bar chart widget
Object to wrap a List, so that in case a caller provided an immutable List,
you can safely perform mutating operations on it (in which case, it'll get
replaced by an actual mutable list).
Object to wrap a Map, so that in case a caller provided an immutable Map,
you can safely perform mutating operations on it (in which case, it'll get
replaced by an actual mutable Map).
RDBMS action strategy for a field with a FULLTEXT INDEX on it in a MySQL
database.
navigate: build a same-origin in-app link (/app/...) to a table (optionally
filtered), a record, a process, a report or an app, for the UI to route to.
Public source additions derived from configured application features.
Serves the QQQ Next dashboard (qqq-frontend-next static export) from the
classpath at the server root.
Security response headers for the QQQ Next dashboard (QRun-IO/qqq#695).
subclass designed to be used when we want there to be an instance (so code
doesn't have to all be null-tolerant), but there's no one who will ever be
reading the status data, so we don't need to store the object in a
state provider.
Implementation of a code execution logger that just noop's every action.
Load step that does nothing.
Implementation of ProcessTracerInterface that does nothing (no-op).
Implementation of a TransformStep - it does nothing other than take input records
and sets them in the output
Record error message for when something couldn't be found (e.g., a request
to update a record, but it isn't in the backend).
Who a user notification is for.
The kinds of audience.
What a user notification is about.
How a user notification is presented (its icon and color).
One user notification from a producer, passed to QAlerts.notify: "tell
these people this".
Utility for working with security key, nullValueBehaviors.
Aggregate analysis metadata.
Meta-data to provide details of an OAuth2 Authentication module.
Implementation of OAuth2 authentication.
Exception to be thrown during OAuth Token generation.
Exception to be thrown by a request that uses OAuth, if the current token
is expired.
utility class to help table customizers working with the oldRecordList.
Returned once to the requesting client; never stored, logged, audited or put in process state.
Hands one-time secrets from a process step that finished as an ASYNC job to
the first status poll that sees it complete.
Structural comparison of two OpenAPI documents (as parsed YAML/JSON maps),
reporting the changes that would break an existing client of the older one.
Entity bean for OutboundApiLog table
Simple container for two objects
Model containing datastructure expected by frontend parent widget
Specific meta data for frontend parent widget
Generic widget for display a parent widget with children of possible values,
child widgets, and child actions
Explicit, reasoned exceptions to UI/model API parity.
Manage process to pause all quartz jobs
Record error message for when the user didn't have permission to do what they
were trying.
How a core action (Query, Get, Count, Aggregate, Insert, Update, Delete,
Replace, RunProcess, RenderWidget, GenerateReport, Export) should treat
table/process/widget/report permissions and field security locks for the
current session.
Define how a PicoCLI process gets data back to a QProcess.
Model containing datastructure expected by frontend pie chart widget
Full definition of a pivot table - its rows, columns, and values.
Functions that can be applied to Values in a pivot table.
Either a row or column grouping in a pivot table.
How a group-by (rows or columns) should be sorted.
a value (e.g., field name + function) used in a pivot table
Excel styler that does nothing - just takes defaults (which are all no-op) from the interface.
Excel styler that does nothing - just takes defaults (which are all no-op) from the interface.
Interface for classes that know how to apply styles to an Excel stream being
built by POI.
Runnable for the Polling Automation Provider, that looks for records that
need automations, and executes them.
extended version of TableAction, for sharding use-case - adds the shard
details.
Wrapper for a pair of (tableName, automationStatus)
Interface to be used by 2 records in this class - normal TableActions, and
ShardedTableActions.
Metadata specifically for the polling automation provider.
How a form offers possible values while a dependency is unset.
Interface to be implemented by enums which can be used as a PossibleValueSource.
A single possible value option, with an id and a label.
FilterUseCase implementation for the ways that possible value searches
are performed, and where we want to have different behaviors for criteria
that are missing an input value.
Executor for searching possible value sources.
Input for the possible values middleware executor.
Generic meta-data-producer, which should be instantiated (e.g., by
MetaDataProducer Helper), to produce a QPossibleValueSource meta-data
based on a PossibleValueEnum
Generic meta-data-producer, which should be instantiated (e.g., by
MetaDataProducer Helper), to produce a QPossibleValueSource meta-data
based on a QRecordEntity class (which has corresponding QTableMetaData).
Output interface for the possible values middleware executor.
Response object for possible values searches.
Shared utilities for possible values spec definitions.
Meta-data to provide details of a PostgreSQL backend (e.g., connection
params).
QQQ Backend module for working with PostgreSQL databases.
PostgreSQL specialization of the default RDBMS/JDBC action strategy.
PostgreSQL adapter for the
WeekdayOfDateFunction
that generates EXTRACT(ISODOW FROM col) SQL expressions.PostgreSQL adapter for the
WeekdayOfDateTimeFunction
that generates EXTRACT(ISODOW FROM (col AT TIME ZONE 'UTC') AT TIME ZONE ?) SQL expressions.Extension of RDBMSTableBackendDetails, with details specific to a
PostgreSQL table.
PreferenceActionRequestV1 in the user preferences API.
PreferenceActionResponseV1 in the user preferences API.
PreferenceActionV1 in the user preferences API.
PreferenceListV1 in the user preferences API.
PreferenceRowV1 in the user preferences API.
One-time secret.
Run an action on the signed-in user's preferences.
Read one visible section for the signed-in user.
PreferenceSectionPatchRequestV1 in the user preferences API.
Partially update the signed-in user's preferences.
PreferenceSectionV1 in the user preferences API.
PreferencesResponseV1 in the user preferences API.
List visible sections and the signed-in user's preferences.
ThreadFactory implementation that puts a common prefix on all threads.
class for preparing data for the bulk edit processes
Version of PrepareReportStep for a report that runs off a single record.
Process step to prepare for running a report.
Route provider that executes QQQ processes in response to HTTP requests.
process payload shared the processes which are used as process-based-router
processes.
Executor for cancelling a running process.
Middleware input for cancelling a process.
V1 response object for process cancellation.
Endpoint spec for cancelling a running process.
Input for processed audit handlers containing AuditSingleInput objects.
Handler interface for receiving processed audit events.
Authorize server-produced files for the current application and session.
Launch a process as a durable job, as the request's session (DurableJobs
enforces eligibility, permissions, caps and the assistant gate).
Input for POST /processes/{processName}/jobs: the launch request.
Output of a durable job launch.
Response of POST /processes/{processName}/jobs.
POST /processes/{processName}/jobs: run any eligible process as a durable
job ("Run in background").
Calls the instance's ProcessLifecycleListenerInterface implementations.
Instance-level listener for the lifecycle of process runs, registered via
QInstance.withProcessLifecycleListener.
QRecord Entity for ProcessLock table
MetaData producer for Process Locks "system"
Record to hold either a processLock, or an unableToObtainProcessLockException.
QRecord Entity for ProcessLockType table
Utility class for working with ProcessLock table - creating, checking-in,
and releasing process locks.
input wrapper for an overload of the checkin method, to allow more flexibility
w/ whether or not you want to update details invalid input: '&' expiresAtTimestamp (e.g., so a
null can be passed in, to mean "set it to null" vs.
Action to fetch meta-data for a process.
Object that stores adjustments that a process wants to make, at run-time,
to its meta-data.
Input for meta-data for a process.
Output for a process-metaData action
Storage table for process report downloads.
Spec for searching possible values for a field on a process.
Executor for fetching records from a process state.
Middleware input for fetching records from a process state.
Middleware output interface for fetching process records.
V1 response object for process records.
Endpoint spec for fetching records from a process state.
Ownership of the current JVM's process state, separate from client values.
Possible ways the steps of a process can flow.
Simple process summary result object, that lets you give a link to a filter
on a table.
For processes that may show a review invalid input: '&' result screen, this class provides a
standard way to summarize information about the records in the process.
Interface for objects that can be output from a process to summarize its results.
Interface for a class that can provide a ProcessSummary - a list of Process Summary Lines
Simple process summary result object, that lets you give a link to a record
in a table.
Helper class for process steps that want to roll up error summary and/or
warning summary lines.
Interface that can be plugged into the execution of a QProcess, that gets
callbacks from QQQ for events in the lifecycle of a process, which one may
wish to log or otherwise be aware of.
Specialization of process tracer message, to indicate a 'key record' that was
used as an input or trigger to a process.
Basic class that can be passed in to ProcessTracerInterface.handleMessage.
Model containing datastructure expected by frontend process widget
Generic widget for displaying a process as a widget
Tokens and a value-free message supplied before an audit is inserted.
Common (maybe)?
The part of the application's branding that is safe to show before a user
signs in (for example on a login page): names, logo, icon and accent
colors.
Define some standard ways to format the value portion of a PossibleValueSource.
Abstract base class for any and all QQQ lambda handlers.
The producer API for alerts ("manage by exception").
Declares a kind of problem a qbit or app can report (e.g. cdn.purge.dead),
so the system "knows about" every alert source.
Interface shared by meta-data objects which can be placed into an App.
Second-generation qqq javalin server.
One entry point that starts everything an application has configured, in
this order:
- its QApplicationJavalinServer (which builds the application's QInstance);
- the QScheduleManager, when that instance has anything scheduled (or the
scheduledJob table);
- each of the instance's runtime services (QInstance.withRuntimeService).
Settings for QApplicationLauncher:
- serverCustomizer: configures the QApplicationJavalinServer before it
starts (port, dashboards, route providers, etc)
MetaData definition of an App - an entity that organizes tables invalid input: '&' processes
and can be arranged hierarchically (e.g, apps can contain other apps).
A section of apps/tables/processes - a logical grouping.
Annotation to place onto fields in a QRecordEntity, to mark them as associated
record lists
Metadata for registering an audit handler in a QInstance.
Exception thrown doing authentication
Meta-data to provide details of an authentication provider (e.g., google, saml,
etc) within a qqq instance
Interface for customizing behavior of an Authentication module.
This class is responsible for loading an authentication module, by its name, and
returning an instance.
Interface that a QAuthenticationModule must implement.
Enum to define the possible authentication types
Meta-data definition of a qqq service to drive record automations.
Enum to define the possible automation provider types
Meta-data to provide details of a backend (e.g., RDBMS instance, S3 buckets,
NoSQL table, etc) within a qqq instance
Jackson custom deserialization class, to return an appropriate sub-type of
A QBackendMetaData, based on the backendType specified within.
This class is responsible for loading a backend module, by its name, and
returning an instance.
Interface that a QBackendModule must implement.
Meta-Data to define a backend-step in a process in a QQQ instance.
Container wherein backend modules can track data and/or objects that are
part of a transaction.
Exception thrown when an API HTTP request failed due to a bad status code.
User-facing exception for when user provided bad or missing data in their request
QQQ base class for "Custom" lambda handlers.
extension of MetaDataProducerInterface, designed for producing meta data
within a (java-defined, at this time) QBit.
extension of MetaDataProducerInterface, designed for producing meta data
within a (java-defined, at this time) QBit.
Interface for configuration settings used both in the production of meta-data
for a QBit, but also at runtime, e.g., to be aware of exactly how the qbit
has been incorporated into an application.
thrown by QBitConfig.validate() if there's an issue.
Meta-data to define an active QBit in a QQQ Instance.
2nd generation interface for top-level meta-data production classes that make
a qbit (evolution over QBitProducer).
interface for how a QBit's meta-data gets produced and added to a QInstance.
While a qbit is being produced, track the context of the current config
and metaDataProducerMultiOutput that is being used.
Meta-Data to define branding in a QQQ instance.
Exception thrown while executing custom code in QQQ.
Interface to provide logging functionality to QCodeExecution (e.g., scripts)
Interface to be implemented by language-specific code executors, e.g., in
qqq-language-support-${languageName} maven modules.
Interface for classes that can accept a QCodeExecutor object via a setter.
Utility to load code for running QQQ customizers.
Pointer to code to be ran by the qqq framework, e.g., for custom behavior -
maybe process steps, maybe customization to a table, etc.
Specialized type of QCodeReference that takes a lambda function object.
a code reference that also has a map of properties.
Possible types for Q-Code entities
Possible usages for Q-Code entities
QQQ log4j implementation, used within a QLogger, to "collect" log messages
in an internal list - the idea being - for tests, to assert that logs happened.
Helper class for QPicCliImplementation to build the Command
Types of UI Components that can be specified in frontend process steps.
A collection of thread-local variables, to define the current context of the
QQQ code that is running.
The scope of the credential a session was created from - e.g. an access
token (Authentik app-password / OAuth client) limited to some tables, or to
reading.
Possible query criteria field operators
Interface to be implemented by user-defined code that serves as the backing
for a CUSTOM type possibleValueSource
Type parameter `T` is the id-type of the possible value.
Abstract base class for all errors to be attached to QRecords.
Meta-data for an ESB destination - a queue or topic on a provider.
Meta-data for a message broker that ESB destinations live on.
The ESB trigger runtime on this node: one EsbTriggerRunner for each trigger
(EsbProcessMetaData.triggers) in an instance.
Base class for checked exceptions thrown in qqq.
Annotation to place onto fields in a QRecordEntity, to add additional attributes
for propagating down into the corresponding QFieldMetaData
Jackson custom deserialization class, to return an appropriate sub-type of
A QBackendMetaData, based on the backendType specified within.
Meta-data to represent a single field in a table.
A section of fields - a logical grouping.
Default implementation of
QFieldSectionAlternativeTypeInterface.marker interface for classes (enums, most likely) that can be used as keys
in
QFieldSection's alternative types map.Possible data types for Q-fields.
A single criteria Component of a Query
Custom jackson deserializer, to deal w/ abstract expression field
Bean representing an element of a query order-by clause.
Bean representing an element of a query order-by clause - ordering by an
aggregate field.
Bean representing an element of a query order-by clause - ordering by a
group by
Exception thrown while generating reports
Version of QAppMetaData that's meant for transmitting to a frontend.
Shallow frontend description of a named association and its declared join.
A metadata-defined view whose filter is evaluated in the caller's session.
Definition of a UI component in a frontend process steps.
Version of an ExposedJoin for a frontend to see
Version of QFieldMetaData that's meant for transmitting to a frontend.
Version of QProcessMetaData that's meant for transmitting to a frontend.
A related-record picker as published to frontends: the metadata with its
tables resolved, defaults applied, and what this user may do with it.
Version of QReportMetaData that's meant for transmitting to a frontend.
Meta-Data to define a front-end step in a process in a QQQ instance (e.g.,
a screen presented to a user).
Version of QTableMetaData that's meant for transmitting to a frontend.
Version of a variant for a frontend to see
Frontend-facing representation of a
QVirtualFieldMetaData,
extending QFrontendFieldMetaData with additional flags that indicate
whether the virtual field can be used as a query filter criterion and/or
included in query output selections.Version of QWidgetMetaData that's meant for transmitting to a frontend.
Meta-Data to define the Input Data for a QQQ Function
Meta-Data to define the Output Data for a QQQ Function
meta-data definition of "Help Content" to show to a user - for use in
a specific "role" (e.g., insert screens but not view screens), and in a
particular "format" (e.g., plain text, html, markdown).
interface that can be added to a QSupplementalInstanceMetaData, to receive
QHelpContent records during instance boot or upon updates in the help content
table.
QQQ default or standard HelpRoles.
class to contain httpResponse data from closable responses
Icon to show associated with an App, Table, Process, etc.
Marker - that a piece of code should be ignored (e.g., a field not treated as
a @QField)
Field Mapping implementation that uses Integer keys (e.g., from a CSV file
WITHOUT a header row).
QQQ standard input sources -- the system, or users.
Container for all meta-data in a running instance of a QQQ application.
Methods for adapting qInstances to serialized (string) formats (e.g., json),
and vice versa.
POC of a class that is meant to review meta-data for accuracy vs. real backends.
As part of helping a QInstance be created and/or validated, apply some default
transformations to it, such as populating missing labels based on names.
Interface for additional / optional enrichment to be done on q instance members.
Utility methods for working with (dynamic, from a table) HelpContent - and
putting it into meta-data in a QInstance.
Exception thrown during qqq-starup, if a QInstance is found to have validation
issues.
Object used to mark a QInstance has having been validated.
Object used to record state of a QInstance having been validated.
Class that knows how to take a look at the data in a QInstance, and report
if it is all valid - e.g., non-null things are set; references line-up (e.g.,
a table's backend must be a defined backend).
Interface for additional / optional q instance validators.
Java
Access-Logger used for QJavalin handlers.
input to filter method (from javalin meta data), to decide if entry should be logged.
Types of log entries - useful for a filter (from javalin meta data).
methods for handling qqq API requests in javalin.
QQQ Javalin implementation.
MetaData specific to a QQQ Javalin server.
methods for handling qqq processes in javalin.
Interface for classes that can provide a list of endpoints to a javalin
server.
endpoints and handlers for deal with record scripts
Utility methods shared by javalin implementations
Definition of how 2 tables join together within a QQQ Instance.
Field Mapping implementation that uses string keys (e.g., from a CSV file
with a header row, or from one JSON object to the proper qqq field names)
A resolved key: its bytes, the id (the keyRef) that names it, and its version.
Source of symmetric key-encryption keys, addressed by a key reference.
QQQ abstraction over an AWS Lambda Request.
QQQ abstraction over an AWS Lambda Response.
Wrapper for
A list of items that can be selected by a user of a qqq application.
Utility class for programmatically modifying menu structures.
Default menu definition for the view screen actions slot.
Sub-list containing the footer menu items (system-wide operations).
Sub-list containing the header menu items (primary CRUD operations).
abstract base class for menu items.
Menu item that represents a built-in action provided by the QQQ framework.
Interface marker for built-in option types.
Enumeration of default built-in menu item options provided by QQQ.
Interface for objects that contain a collection of menu items.
Menu item that represents a visual divider or separator in a menu.
Menu item that triggers a file download from a field in the current record.
interface for different types of menu items.
Utility class for matching menu items based on various criteria.
Menu item that triggers the execution of a QQQ process.
Menu item that contains a sub-list of other menu items.
Menu item that contains a nested sub-menu of other menu items.
Enumeration of standard menu slot locations where menus can be displayed
in a QQQ application.
Interface to mark objets that can be used as a "slot", e.g., where a menu
should be used or displayed in an application.
This class is responsible for loading a messaging provider, by its name, and
returning an instance.
Base class for qqq messaging-providers.
interface common among all objects that can be considered qqq meta data -
e.g., stored in a QInstance.
annotation to go on a QRecordEntity class, which you would like to be
processed by MetaDataProducerHelper, to automatically produce some meta-data
objects.
annotation to go on a PossibleValueEnum class, which you would like to be
processed by MetaDataProducerHelper, to automatically produce possible-value-
source meta-data based on the enum.
To avoid having secrets (passwords, access keys, etc) committed into meta data
files, as well as to just let some meta data not be hard-coded, this class is
used by the Enricher to "promote" values, such as ${env.ACCESS_KEY}
to be read from the environment (or other secret providers (to be implemented)).
javalin-handler that serves both rapidoc static html/css/js files, and
dynamically generated openapi json/yaml, for a given list of qqq middleware
versions
Exception thrown while doing module-dispatch
User-facing exception for when something wasn't found (e.g., a named table or
record-by-id).
Exception thrown if user doesn't have permission for an action
QQQ PicoCLI implementation.
An actual possible value - an id and label.
Declares that a table-type possible value source is chosen with a record
picker (a searchable, filterable, paged dialog) rather than only an inline
dropdown - for sources over tables that grow large (e.g., 100,000+ media).
One ordering offered by the picker.
Meta-data to represent a "Possible value" - e.g., a translation of a foreign
key and/or a limited set of "possible values" for a field (e.g., from a foreign
table or an enum).
Possible types (e.g, kinds of data sources) for a possible value source.
Class responsible for looking up possible-values for fields/records and
make them into display values.
QQQ Utility Lambda to post input data to SQS.
When a process/function can't run because it's missing data, this interface
defines how the core framework goes back to a middleware (and possibly to a
frontend) to get the data.
Builder pattern for creating a QProcessCallback
Constructor for commonly used QProcessCallback's
Meta-Data to define a process in a QQQ instance.
base-class for bean-like classes to represent the fields of a process.
QRecord Entity for QQQBackend table - e.g., table that stores an id, name
and the label for all backends in the QQQ application.
Provides meta data for the QQQBackend table, PVS, and a cache table.
Utility class for accessing QQQBackend records (well, just their ids at this time)
Takes care of inserting upon a miss, and dealing with the cache table.
QRecord Entity for QQQProcess table - e.g., table that stores an id, name
and the label for all processes in the QQQ application.
Provides meta data for the QQQProcess table, PVS, and a cache table.
Utility class for accessing QQQProcess records (well, just their ids at this time)
Takes care of inserting upon a miss, and dealing with the cache table.
Object made available to scripts for access to qqq api (e.g., query, insert,
etc, plus object constructors).
QRecord Entity for QQQTable table - e.g., table that stores an id, name
and the label for all tables in the QQQ application.
possible-value source provider for the `QQQ Table` PVS - a list of all tables
in an application/qInstance (that you have permission to see)
Provides meta data for the QQQTable table, PVS, and a cache table.
Utility class for accessing QQQTable records (well, just their ids at this time)
Takes care of inserting upon a miss, and dealing with the cache table.
Full "filter" for a query - a list of criteria and order-bys
Class to help deduplicate redundant criteria in filters.
Adapter class to convert back and forth between JSON strings and QQueryFilters
MetaData to define a message queue, which must exist within a QueueProvider.
Define a provider of queues (e.g., an MQ system, or SQS)
Data Record within qqq.
Methods for going back and forth from QRecords to API-versions of objects
Input wrapper for the methods in
QRecordApiAdapter that adapt from
QRecords To API objects.Base class for entity beans that are interoperable with QRecords.
Reflective information about an association in a QRecordEntity
Reflective information about a field in a QRecordEntity
Base class for enums that are interoperable with QRecords.
Meta-Data to define how to view a qqq record list (e.g., what fields to show).
Class to convert QRecords to CSV Strings.
Class to convert QRecords to TSV (Tab Separated Value) Strings.
options for how special-char values (\n, \t, \r, and \\) should be sanitized
Utility methods for working with QRecords (and the values they contain)
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.
A related-record picker declared on a table: a modal for choosing records of
a target table, for a foreign-key field (
RelatedRecordPickerMode.SINGLE),
to add as child rows through an association
(RelatedRecordPickerMode.MULTI_CHILD), or to link and unlink through
an association to a join table (RelatedRecordPickerMode.LINK).Meta-data definition of a source of data for a report (e.g., a table and query
filter or custom-code reference).
Field within a report
Exception thrown while generating reports
Meta-data definition of a report generated by QQQ
Base class for unchecked exceptions thrown in qqq.
A long-running service that an application starts along with its server,
and stops at shutdown (e.g., a message consumer).
QQQ service to manage scheduled jobs, using 1 or more Schedulers - implementations
of the QSchedulerInterface
Meta-data to define scheduled actions within QQQ.
Define a type of security key (e.g., a field associated with values), that
can be used to control access to records and/or fields
Helper class for interacting with the session store.
Interface for session storage providers.
Registry for session store providers.
QQQ Slack implementation.
Class to provide QQQ Standard table invalid input: '&' process actions via AWS Lambda.
A step for a state-machine flow based Process.
Abstract Base class for status messages (errors or warnings) that can be
attached to QRecords.
Meta-Data to define a step in a process in a QQQ instance.
Jackson custom deserialization class, to return an appropriate sub-type of
QTableBackendDetails, based on the backendType of the containing table.
Interface for actions that a backend can perform, based on streaming data
into the backend's storage.
A single selected column used as the sole value of an IN or NOT_IN criterion.
Base-class for app-level meta-data defined by some supplemental module, etc,
outside of qqq core
Base-class for field-level meta-data defined by some supplemental module, etc,
outside of qqq core
Base-class for instance-level meta-data defined by some supplemental module, etc,
outside of qqq core
Base-class for process-level meta-data defined by some supplemental module, etc,
outside of qqq core
Base-class for table-level meta-data defined by some supplemental module, etc,
outside of qqq core
Special session, indicating that an action being executed is being done not
on behalf of a (human or otherwise) user - but instead, is the application/
system itself.
Details about how this table's record automations are set up.
Base class where backends can specify additional per-table meta-data.
Jackson custom deserialization class, to return an appropriate sub-type of
QTableBackendDetails, based on the backendType of the containing table.
Meta-Data to define a table in a QQQ instance.
A user-facing refusal because a capacity limit was reached (HTTP 429), e.g.,
too many queued durable jobs for one user.
Singleton to provide access between QQQ and the quartz Scheduler system.
Action to run a query against a table.
After running a query, if it's for a table that's a CacheOf another table,
see if there are any cache use-cases to apply to the query result.
action flags that can be put in a query request to control behavior in
this class.
Shared query/count/aggregate expansion and bounded sub-query execution.
Information about the query that an application (or qqq service) may know and
want to tell the backend, that can help influence how the backend processes
query.
Input data for the Query action
Todo - maybe make a class between AbstractTableActionInput and {QueryInput,
CountInput, and AggregateInput}, with common attributes for all of these
"read" operations (like, queryHints,
Interface for the Query action.
Part of query (or count, aggregate) input, to do a Join as part of a query.
define the types of joins - INNER, LEFT, RIGHT, or FULL.
Row locks a query may take, on backends that support them (see
QBackendModuleInterface.supportsQueryLockMode).
Note that much of this class is/was ported (well, copied) to BaseRDBMSActionStrategy
around 2025-01, during the addition of SQLite backend module.
Common getters invalid input: '&' setters, shared by both QueryInput and CountInput.
Common getters invalid input: '&' setters, shared by both QueryInput and GetInput.
Output for a query action
query_records: records of a readable table matching a filter - only exposed
field values (masked where MASKED), at most maxRowsToModel rows, each with a
record ref - plus a "records" render payload with an openHref to the
filtered list.
Process used by the saved bulkLoadProfile dialogs
Load the saved view records available to the current user for the specified
table.
QRecord Entity for QueryStat table
interface for plug-able objects that can be added to
QueryStatManager,
to accept QueryStat objects after they are built.QRecord Entity for QueryStatCriteriaField table
QRecord Entity for QueryStatJoinTable table
Singleton, which starts a thread, to store query stats into a table.
QRecord Entity for QueryStatOrderByField table
Utility for building a query string - taking care of things like:
- do I need the "?"
Help parse query strings into maps.
Types of queues supported by QQQ.
Entity bean for the quick saved view table - a many to one join
with SavedView, for display in as a "quick" view.
Model containing datastructure expected by frontend AWS quick sight widget
TODO: this might just be an IFrameChart widget in the future
AWS Quicksite specific meta data for frontend dashboard widget
Widget implementation for amazon QuickSight charts
Model a file that a user uploaded (or otherwise submitted to the qqq backend).
Exception with a good-quality message meant to be shown to an end-user.
Exception for when there's a problem with a value (like a string that you need
to be an integer, but it isn't).
Utility to apply display formats to values for records and fields.
Annotation to place onto fields in a QRecordEntity, to mark them as virtual
fields.
Subclass of QFieldMetaData that is used for virtual fields - that is -
fields which don't exist in the backend system, but may instead be the result
of calculations or other non-stored data.
Class to wrap warning messages to attach to QRecords.
Base class for the data returned by rendering a Widget.
Base metadata for frontend dashboard widgets
Interface for qqq widget meta data
Connection factory builder for RabbitMQ (4.x), via the RabbitMQ JMS client.
Bridge to the RabbitMQ JMS 3.9 wire decoder, which is package-private.
Broker adapter for RabbitMQ: queue info and purge through the management
plugin's HTTP API, on the provider's managementUrl (e.g.,
http://host:15672).
Model containing datastructure expected by frontend bar raw html widget
Why (and under what authority) a caller is asking for a "raw read" - see
QueryInput.withRawRead(RawReadReason).Meta-data to provide details of an RDBMS backend (e.g., connection params)
QQQ Backend module for working with Relational Databases (RDBMS's).
RDBMS conditional update: one
UPDATE t SET ... WHERE <filter>
statement, so the compare and the set are atomic in the database.RDBMS transaction opened by RDBMSBackendModule.openConsistentReadTransaction:
a (read-only, by default) transaction on one connection, started such that
every table read through it sees one snapshot.
RDBMS-specific extension of
BackendFieldFunctionAdapterInterface
for adapting a FieldFunction into SQL expressions.RDBMS adapter for the
StringLengthFunction that generates a
CHAR_LENGTH(col) SQL expression.RDBMS adapter for the
SubStringFunction that generates SQL
SUBSTRING(col FROM ? [FOR ?]) expressions.Extension of QTableBackendDetails, with details specific to an RDBMS table.
note - this class is pretty mysql-specific
RDBMS implementation of backend transaction.
Only the fields which exist in the record's values map will be updated.
RDBMS adapter for the
WeekdayOfDateFunction that generates
MySQL-compatible WEEKDAY(col) + 1 SQL expressions.RDBMS adapter for the
WeekdayOfDateTimeFunction
that generates MySQL-compatible WEEKDAY(CONVERT_TZ(col, ?, ?)) + 1 SQL expressions.Public qbit entry point: RealtimeBus.get(instance).publish(message).
Best-effort invalidations shared by core and qbits.
Typed realtime UI API payload.
Typed realtime UI API payload.
Transport-neutral subscription executor; stream attachment is done in handleOutput.
Internal execution input; wire schemas are separate components.
Internal execution output; never serialized as a wire payload.
Typed realtime UI API payload.
One server connection registry.
A bounded transport queue; empty event is the internal close marker.
Wire frame, with a null event representing a comment ping.
job.progress data, sent on the owner and job record channels.
A small invalidation hint.
Instance realtime transport configuration.
Typed realtime UI API payload.
Typed realtime UI API payload.
Typed realtime UI API payload.
Typed realtime UI API payload.
Own transport resources until producers and HTTP requests have drained.
Typed realtime UI API payload.
Authenticated v1 SSE stream.
Typed realtime UI API payload.
Typed realtime UI API payload.
Change channels on a connection belonging to the authenticated session.
Typed realtime UI API payload.
What a target's reconcile lookup (by idempotency key or natural id) found
for an effect whose delivery outcome is unknown
The three outcomes.
Empty means access could not be determined.
Get the logs of a record's associated script revision - requiring that the
record be readable, as the legacy developer route does.
Input for the v1 route that gets the logs of a record's associated script revision.
Output of the route that gets the logs of a record's associated script
revision.
Response for the route that gets the logs of a record's associated script
revision.
Get the logs of a revision of a record's associated script (developer mode).
Store a new revision of a record's associated script - requiring EDIT
permission on the record's table, as the legacy developer route does.
Input for the v1 route that stores a new revision of a record's associated script.
Output of the route that stores a new revision of a record's associated
script.
Response for the route that stores a new revision of a record's associated
script.
Store a new revision of a record's associated script (developer mode).
Interface for custom-codes to run as an automation action
Input data for the RecordAutomationHandlerInterface.
Utility class for updating the automation status data for records
What a RecordChangeListenerInterface receives after a successful write.
Publish committed invalidations only for tables using presence or following.
Runs the instance's record change listeners.
Preserve required-listener failures through actions' event preparation guards.
Instance-level listener that InsertAction, UpdateAction and DeleteAction call
with the records they wrote successfully.
The kinds of record changes that a RecordChangeListenerInterface hears about.
Typed realtime UI API payload.
Interface with utility methods that pre insert/update/delete customizers
may want to use.
Container for an old value and a new value.
One of a table's associated scripts, as shown in developer mode for a
record: its definition, script type, and the script the record references
(if any) with its revisions, plus the fields for testing it.
Get a record for developer mode, with its table's associated scripts - with
the same permission checks and data as the legacy developer route.
Input for the v1 record developer-mode route (a record with its associated scripts).
Output of the record developer-mode route: the record, and the details of
each of its table's associated scripts.
Response for the record developer-mode route.
Record "developer mode": a record, with its table's associated scripts
(the script the record references, its revisions, and fields for testing).
Record "developer mode" logic - a record's associated scripts with their
revisions and test fields, a script revision's logs, and storing a new
revision - shared by the legacy script routes (QJavalinScriptsHandler) and
the v1 developer-mode specs, so that both apply the same permission checks
and return the same data.
Everything developer mode shows about one of a table's associated scripts,
for one record.
Read a record (under the user's table read permission and record security
locks - a 403 or 404 otherwise), then build the developer panels that the
instance's providers contribute for it.
Output of the record developer panels endpoint.
Response of the record developer panels endpoint.
GET /table/{tableName}/{primaryKey}/developer/panels - the panels that
developer panel providers (built-in, modules, qbits) contribute to a
record's developer view.
Generic meta-data-producer, which should be instantiated (e.g., by
MetaDataProducerHelper), to produce a QPossibleValueSource meta-data
based on a QRecordEntity class (which has corresponding QTableMetaData).
Record collaboration features and their optional table permission suffixes.
Scope of an override.
Runtime feature declarations, collected only during overlay refresh.
Feature grants always require READ; the edit fallback also requires stored WRITE locks.
Adapt collaboration declarations to the generic table feature permission registry.
Shared feature declarations; also the instance-level supplemental metadata.
Merge code levels, then runtime levels, then enforce hard limits.
Build session-specific frontend publication and record summaries.
Contribute optional summary values and namespaced extensions for one visible record.
Executor for the record field download endpoint.
Input for the record field download endpoint.
Output interface for the record field download endpoint.
Response wrapper for the record field download endpoint.
Spec for the record field download endpoint
(GET /table/{tableName}/{primaryKey}/{fieldName}/{filename}).
A record follower and notification preferences, with an optional reason for following.
Best-effort access to the instance-level record followers provider.
Provide record followers without coupling consumers to a collaboration qbit.
How are records stored in the files in a filesystem backend?
Generic widget to display a list of records.
Utility to help processes lookup records.
Object to connect a producer of records with a consumer.
Subclass of BufferedRecordPipe, which ultimately sends records down to an
original RecordPipe.
A reference to a record with one primary key.
Parent lock propagation and after-commit cleanup for registered record references.
Cleanup invoked only after successful parent deletion commit.
Core enforcement shared by all record-reference table actions; no session or all-access bypass.
Record search across tables: matches a free-text term against the
search fields of each table that
declares them, and returns each match's table, primary key and label.A secondary field value of a record search result (a search field that is
not part of the record label), for display under the record label.
A secondary field value of a record search result, to show under its label.
Executes record search across the tables that declare search fields, as
the session's user (tables it may not read are skipped; record security
locks apply).
A plain-text snippet of one field of a record search result, with the spans
that match the search term.
One matched span in a record search highlight's text: character offsets,
start inclusive and end exclusive.
One matched span in a record search highlight: character offsets into its text.
A plain-text snippet of a field that matches the search term, with the matched spans.
Input for
RecordSearchAction:
a free-text search term, matched against the search fields of every table
that declares them (optionally only the named tables).Input for the record search endpoint.
Output for
RecordSearchAction:
matching records, grouped by table in instance order.Output of the record search endpoint.
Search terms beginning with # are passed through to providers as-is.
Outcome of the record search provider in one search.
How the instance's record search provider fared in one search.
How the instance's record search provider fared in this search.
Response of the record search endpoint.
One record matched by record search: its table, primary key and label.
One record matched by record search.
Order of the results within each table of a record search.
What searched a table in a record search.
POST /search - record search across the tables that declare search fields.
Summary of the record search of one table: how many results it returned,
whether it has more, and what searched it.
Summary of the record search of one table.
Built-in developer panel: the table's record security locks, and for each,
why the current user can see this record (an all-access key, a matching key
value, or the lock's null-value behavior).
Define (for a table) a lock that applies to records in the table - e.g.,
a key type, and a field that has values for that key.
standard filtering operations for lists of record security locks.
Best-effort optimistic preflight using the already permission-filtered old rows.
A stale optimistic version.
Carries a per-record conflict to transports that use an HTTP conflict response.
Meta Data Producer for RedirectState table
Utilities for bean-like classes (e.g., QRecordEntity, QProcessPayload) that
use reflection to understand their bean-fields
Authenticated encryption (AES-256-GCM) of OAuth2 refresh tokens at rest
(#1048), so a copy of the refresh-token table (a backup, a replica, an
over-broad DB role) does not hand out live credentials.
A related-record picker of a table (docs/RELATED-RECORD-PICKER.md): what it
picks, how to show it, and what the current user may do with it.
Serves related-record pickers (QRelatedRecordPicker): query the target
table, prepare child rows, add them, and remove links.
A picker with its tables and join fields worked out.
Response of the relatedRecordPicker add route: the inserted rows.
POST /table/{tableName}/relatedRecordPicker/{pickerName}/add
(docs/RELATED-RECORD-PICKER.md).
Runs a relatedRecordPicker route's operation through
RelatedRecordPickerAction (which does every permission and security check).
Input for RelatedRecordPickerAction: the table that owns the picker
(tableName), the picker, the parent record and the operation's arguments.
Input for the relatedRecordPicker routes: which operation, and the core
action's input.
The operations of the relatedRecordPicker routes.
The relationship a
QRelatedRecordPicker picks for.Output of RelatedRecordPickerAction.
Output of the relatedRecordPicker routes: each response takes what its
operation returns from the core action.
Response of the relatedRecordPicker prepare route: unsaved child rows.
POST /table/{tableName}/relatedRecordPicker/{pickerName}/prepare
(docs/RELATED-RECORD-PICKER.md).
Response of the relatedRecordPicker query route.
POST /table/{tableName}/relatedRecordPicker/{pickerName}/query
(docs/RELATED-RECORD-PICKER.md).
Response of the relatedRecordPicker remove route.
POST /table/{tableName}/relatedRecordPicker/{pickerName}/remove
(docs/RELATED-RECORD-PICKER.md).
Shared definitions for the relatedRecordPicker routes
(docs/RELATED-RECORD-PICKER.md).
Entity bean for the rendered report table
Process step to actually execute rendering a saved report.
define process for rendering saved reports!
initial backend-step before rendering a saved report.
API-Customizer for the RenderSavedReport process
Class that helps prepare the RenderSavedReport process for use in an API
api process output specifier for the RenderSavedReport process
Basic action to render a template!
Class for loading widget implementation code and rendering of widgets
Input data container for the RenderWidget action
Output for an Export action
render_widget: render a dashboard widget the current user may see, with the
widget permission check the widget endpoint makes.
Action to do a "replace" - e.g: Update rows with unique-key values that are
already in the table; insert rows whose unique keys weren't already in the
table, and delete rows that weren't in the input (all based on a
UniqueKey that's part of the input)
Note - the filter in the ReplaceInput - its role is to limit what rows are
potentially deleted.
single entry in ReportColumns object - as part of SavedReport
type of object expected to be in the SavedReport columnsJSON field
Interface to be implemented to do a custom source of data for a report
(instead of just a query against a table).
Member of report invalid input: '&' export Inputs, that wraps details about the destination of
where invalid input: '&' how the report (or export) is being written.
QQQ Report/export file formats
sub-set of ReportFormats to expose as possible-values in-apps
Input for a Report action
A report in the instance's meta-data: what a frontend needs to list it and
to run it (through its process, or the report route when it has none).
Output for a Report action
Run a report and stream the generated file, as the legacy
GET /reports/{reportName} route does: 404 for an unknown report, the report
permission check, the report's input fields read from the request (400 for a
missing required one or a value of the wrong type), and the file streamed in
the requested format while it is generated.
Input for running a report and streaming the generated file
(GET /reports/{reportName}).
Spec for running a report and downloading the generated file
(GET /reports/{reportName}) - the v1 form of the legacy streaming report
route, for reports that are not run through a process.
Utility for verifying that the RenderReports process works for all fields,
on all tables, and all exposed joins.
Types of reports that QQQ can generate
Note - exists under 2 names, for the RenderSavedReport process, and for the
ScheduledReport table (and can be used in your custom code too:
by default, in qqq backend core, we'll assume this widget is being used on the
view screen for a ScheduledReport, with field names that we know from that table.
Interface for customizer on a QReportView.
Management process to reschedule all scheduled jobs (in all schedulers).
How an open alert of a type is closed automatically.
ActionFlag for "restore-mode" writes - data operations such as restoring a
backup, which must put records back exactly as they were, rather than treating
the write as a business event.
Helpers for the pieces of Insert/Update that behave differently under a
RestoreWriteFlag.
Manage process to resume all quartz jobs
Interface for authenticating HTTP requests in Javalin route providers.
Interface for after handlers used by IsolatedSpaRouteProvider.
Interface for before handlers used by IsolatedSpaRouteProvider.
Interface for bidirectional mapping between Javalin HTTP context and QQQ process execution.
Widget data for the row builder widget.
Generic widget for a form that lets a user add rows.
Widget Meta Data Builder for this widget type.
Interface allowing customization of the RunAdHocRecordScriptAction
enum specifying customizers on the run ad hoc script process
Action handler for running backend steps as part of processes.
Input data container for the RunBackendStep action
Output data container for the RunBackendStep action
RecordAutomationHandler implementation that is called by automation runner
that doesn't know to deal with a TableTrigger record that it received.
Action handler for running q-processes (which are a sequence of q-steps).
Input data container for the RunProcess action
Output data container for the RunProcess action
Extract step for the run-record process.
Load step for the runRecordScript process - runs the script on a page of records
Transform step run-record-script process.
Definition for Basic process to run a report.
define process for rendering scheduled reports - that is - a thin layer on
top of rendering a saved report.
Process to manually run table automations, for a table.
An instance-identity scoped, atomic overlay.
Runtime table fields, virtual fields, presentation and feature overrides.
Runtime custom field metadata and storage.
S3 backend meta data.
QQQ Backend module for working with AWS S3 filesystems
When the S3 client calculates request checksums and validates response
checksums.
Builds (and caches) AWS SDK v2 S3 clients from S3BackendMetaData.
One object found by an S3 listing: the "file" type that the S3 filesystem
actions work with.
(mass, streamed) storage action for s3 module
S3 specific Extension of QTableBackendDetails
OutputStream implementation that knows how to stream data into a new S3 file.
Utility methods for working with AWS S3 (or any S3-compatible store), on an
AWS SDK v2 S3Client.
An HTTP client for calling URLs that users typed in (webhook endpoints,
callbacks), which must not be usable to reach the internal network (SSRF).
Resolves a host name to addresses (replaceable in tests to simulate DNS).
An outbound request was refused by policy or failed before a response.
What went wrong.
Limits for
SafeHttpClient.The result of a
SafeHttpClient request: the status, the headers
(first value of each, names lower-cased), at most the policy's
maxResponseBytes of the body, whether the body was cut off, the
address actually connected to and the duration.Entity bean for the savedBulkLoadProfile table
Entity bean for the saved report table
Utility for verifying that the RenderReports process works for all report
records stored in the saved reports table.
GenerateReportAction takes in ReportMetaData.
Entity bean for the saved view table
Define MetaData for the Saved Views functionality.
Unique identifier for a thing that can be scheduled
Factory to produce SchedulableIdentity objects
Schedulable process runner - e.g., how a QProcess is run by a scheduler.
Interface for different types of schedulabe things that can be run
Schedulable SQSQueue runner - e.g., how an SQSQueuePoller is run by a scheduler.
Schedulable TableAutomations runner - e.g., how a table automations are run
by a scheduler.
Management process to schedule all new scheduled jobs (in all schedulers).
Scheduled processes as durable jobs (spec section 2.4, "Scheduled").
enum of core schedulable types that QQQ schedule manager directly knows about.
Entity bean for the scheduled report table
Utility methods used by various schedulers.
This class facilitates generating OpenAPI Schema objects based on reflectively
reading classes and annotations
The difference between two table schema fingerprints' descriptors: fields
added, removed and changed, plus any change to the table-level properties
(name, primary key, backend type, unique keys, associations).
One changed field: which attributes differ, with their before and after values.
One changed table-level property (e.g., primaryKeyField or uniqueKeys).
ScriptTypeFileMode - possible value enum
search_help: keyword search over the app's own documentation - the names,
labels, help content and aiDescriptions of the apps, tables, fields,
processes and widgets the current user can see (exposed tables and fields
only).
Class responsible for looking up possible-values for fields/records and
make them into display values.
record to store "computed" values as part of a possible-value search -
e.g., ids type-convered, and lower-cased labels.
Input for the Search possible value source action
Output for the Search possible value source action
search_records: free-text record search (RecordSearchAction - and so any
record search provider, e.g.
Whether a search term is ordinary text or an explicit tag term.
Utility class for working with AWS Secrets Manager.
Factory class for creating "standard" qfield sections.
Utility to help query and aggregate actions validate the fieldNames being
selected, aggregated, grouped by.
Provider-neutral message input.
Provider result.
Outcome of a provider accepting or declining a message.
Result of resyncing one table's key sequence, as returned by
QBackendModuleInterface.resyncKeySequences.
What happened for a table.
SFTP backend meta data.
QQQ Backend module for working with SFTP filesystems (as a client)
(mass, streamed) storage action for sftp module
SFTP specific Extension of QTableBackendDetails
action for testing credentials for an SFTP backend connection
As a component of a ShareableTableMetaData instance, define details about
one particular audience type.
meta data to attach to a table, to describe that its records are shareable.
utility methods shared by s3 invalid input: '&' local-filesystem utils classes
Entity bean for the shared saved bulk load profile table
Entity bean for the shared saved report table
Entity bean for the shared saved view table
for a shared record, what scope of access is given.
Simple connection provider - no pooling, just opens a new connection for
every request.
Route provider that serves static files and SPAs from the file system or JAR.
simple implementation of a route authenticator.
QQQ Service (Singleton) that starts up repeating, scheduled jobs within QQQ.
Claims with SELECT ...
Claims the locked candidates inside the transaction.
Utility methods to help with sleeping!
interface for meta data objects that may have come from a qbit, and where we
might want to get data about that qbit (e.g., config or meta-data).
Path-scoped SPA 404 handlers owned by one Javalin configuration.
Utility methods for SPA path handling.
Meta-data to provide details of an SQLite backend (e.g., path to the database file)
SQLite specialization of the default RDBMS/JDBC action strategy
settings that can be applied to either an SQSQueue or an SQSQueueProvider,
to control what the SQSQueuePoller does when it receives from AWS.
SQS subclass of meta-data for a specific Queue
Class to poll an SQS queue, and run process code for each message found.
Meta-data for an source of Amazon SQS queues (e.g, an aws account/credential
set, with a common base URL).
Spec for searching a standalone possible value source (not associated with
a specific table or process field).
Helper for working with process summary lines
Standard class ran by SimpleScheduler.
Filter expression for the start of a calendar period (day, week, month,
quarter or year), in the user's time zone.
Helper to cancel statements that timeout.
QQQ state provider interface.
Possible types of states to be stored.
Utility class for detecting whether a request path represents a static asset
versus a client-side SPA route.
Model containing datastructure expected by frontend statistics widget
Simple status enum - initially for statuses in process status lines.
Model containing datastructure expected by frontend stepper widget
The STEPS plan (and ATOMIC): run any process's backend steps from its launch
point onward, as one chunk, with frontend steps skipped (their values were
collected before launch).
Action to do (generally, "mass") storage operations in a backend.
An idempotent external effect that streams content to a deterministic storage object.
Input for Storage actions.
Action to store a new version of a script, associated with a record.
Process used by the saved bulkLoadProfile dialog
Process used by the saved view dialog
Implementation of a code execution logger that logs into scriptLog and scriptLogLine
tables - e.g., as defined in ScriptMetaDataProvider.
Action to store a new version (revision) of a script.
Bounded, permission-aware reference evaluator for aggregate requests.
Subclass of RunBackendStepInput, meant for use in the pseudo-steps used by
the Streamed-ETL-with-frontend processes - where the Record list is not the
full process's record list - rather - is just a page at a time -- so this class
overrides the getRecords and setRecords method, to just work with that page.
Subclass of RunBackendStepOutput, meant for use in the pseudo-steps used by
the Streamed-ETL-with-frontend processes - where the Record list is not the
full process's record list - rather - is just a page at a time -- so this class
overrides the getRecords and setRecords method, to just work with that page.
Backend step to do a streamed ETL
Backend step to do the execute portion of a streamed ETL job.
Extension to the base StreamedETLBackendStep, unique for where the source
table is a filesystem, where we want/need to collect the filenames that were
processed in the Extract step, so they can be passed into the cleanup step.
Backend step to do a preview of a full streamed ETL job
Definition for Streamed ETL process.
Backend step to do a full validation of a streamed ETL job
Definition for Streamed ETL process that includes a frontend.
Write excel formatted XML to a Writer.
Streaming authenticated encryption of large artifacts (e.g., backup files),
built on Google Tink's StreamingAead (AES256_GCM_HKDF_1MB), which
authenticates every segment and detects truncation.
String version of data aggregator
FieldFunctionType implementation that returns the character length of a
string field's value, equivalent to SQL CHAR_LENGTH().
Utility methods for working with Strings
FieldFunctionType implementation that extracts a substring from a string
field's value, using 1-based indexing (matching SQL SUBSTRING, not Java's
0-based
String.substring(int)).For a summary report, a list of field/value pairs that make up a "key".
Interface to be implemented by enums of the possible supplemental types
Instance-level settings from supplemental modules, for a frontend.
Record error message for when the system was at fault - not the user.
Implementation of a code execution logger that logs to System.out and
System.err (for exceptions)
Runs kernel bookkeeping (the jobs tables themselves) as the system user, so
the owner lock does not hide rows from the kernel.
A body that returns a value and may throw.
GET /table/{tableName}/apis/{apiName}/{version}/openapi: the table's OpenAPI
document in one version of an application API (one listed by
GET /table/{tableName}/apis), for the developer views - so they read it
through the UI API rather than from the API middleware's
{api.path}{version}/{table}/openapi.json.
Lists the application (model) APIs that expose a table, for
GET /qqq/v1/table/{tableName}/apis (TableApisSpecV1).
One API that exposes the table.
One version of an API.
GET /table/{tableName}/apis: the application (model) APIs that expose a
table, with their versions and the path of the table's OpenAPI document in
each, for the developer views.
Definition of a specific action to run against a table
Meta-data to provide details of an Auth0 Authentication module
HTTP requests may only use the capabilities a table declares, in the same
way frontends only offer them: a table without TABLE_COUNT cannot be counted
and a table without TABLE_EXPORT cannot be exported, over any route.
Common interface used by all (core) TableCustomizer types (e.g., post-query,
and {pre,post}-{insert,update,delete}.
Enum definition of possible table customizers - "roles" for custom code that
can be applied to tables.
Model containing datastructure expected by frontend bar chart widget
Executor for the table export endpoint.
Input for the table export endpoint.
Output interface for the table export endpoint.
Response wrapper for the table export endpoint.
Spec for the table export endpoint (POST /table/{tableName}/export).
Serializable table feature permission callback; avoid capturing instance state.
A grantable table feature, optionally implied by a standard table permission.
Shared registry for grantable table features from any module.
Serializable table feature permission callback; avoid capturing instance state.
POST /table/{tableName}/formAdjuster/{identifier}/{event}: run a table
form's adjuster (the table's on-load adjuster, identifier `table:{name}`,
or a field's on-load / on-change adjuster, by its formAdjusterIdentifier).
A menu that a table defines for a slot on a screen, for example the record
view's actions menu (VIEW_SCREEN_ACTIONS) or its additional menus
(VIEW_SCREEN_ADDITIONAL).
One item of a table menu.
API response component for full table metadata, extending
TableMetaDataLight with fields, sections, exposed joins,
supplemental metadata, sharing configuration, and virtual fields.Action to fetch meta-data for a table.
Input for meta-data for a table.
Output for a table-metaData action
action to execute the TableMetaDataPersonalizerInterface assigned to the
QInstance, e.g., to adjust a TableMetaData object to "personalize" the table
for the current user, before (or within) certain backend actions.
Input for the action to personalize the meta-data for a table.
interface for objects that personalize TableMetaData for (user) actions.
Output for the action to personalize the table-metaData
Spec for searching possible values for a field on a table.
A stable SHA-256 fingerprint of the persistent shape of a table, together
with the descriptor (canonical JSON) it was computed from.
possible-value source provider for the `Tables` PVS - a list of all tables
in an application/qInstance.
Whether a table section can be collapsed, and whether it starts open.
subset of the tables PVS custom provider, to only include tables support automations
subset of the tables PVS, to only include tables support automations
Definition for Standard process to sync data from one table into another.
Definition of in-app/user/data-defined triggers (aka, automations).
An idempotent external write keyed by the destination table's natural unique key.
List the variants a table's backend can be scoped to, as the legacy
GET /data/{table}/variants route does - and, beyond it, only for a user who
may read the table (an unknown table is refused the same way) and the
backend's variant options table.
Input for listing the backend variants of a table (GET /table/{tableName}/variants).
Output of listing a table's backend variants.
Response for GET /table/{tableName}/variants.
Spec for listing the variants of a table whose backend uses variants
(GET /table/{tableName}/variants) - the v1 form of the legacy variants route.
Shared behavior of the v1 table insert and update executors, matching the
legacy data routes.
State provider that uses files in the /tmp/ directory.
Interface to be implemented by script-running actions, if they want to allow
themselves to be used for user-testing of their script.
Action to test a script!
Helper to cancel statements that timeout.
Object to help track performance/runtime of codes.
Interface for meta-data classes that can be added directly (e.g, at the top
level) to a QInstance (such as a QTableMetaData - not a QFieldMetaData).
Mark a class as eligible for running through the SchemaBuilder.
What a tracking job (JobTracking.start) is: its owner, label, the process
name that identifies its kind (for example "assistant.turn"), the client
channel, and optionally the record it is about.
Version of a map that uses a transformation function on keys.
Possible events that can trigger a record automation.
TSV (Tab Separated Values) export format straemer implementation
Version of map where string keys are handled case-insensitively.
The AI tool kernel's data access through the UI API: every query, count,
get, search and widget render is a /qqq/v1 operation, invoked in-process
(UiApiInvoker) with the human user's own credentials and the invoker's
client channel (assistant/).
The UI API contract check, shared by core's UiApiContractTest and by the
contract tests of modules and qbits that register extensions.
The credentials a caller's request carried, to forward on in-process UI API
calls so they authenticate exactly as the caller did: whatever the
authentication module (session cookies for OAuth2/OIDC, Auth0, table-based,
mock; Authorization or x-api-key headers for API keys and bearer tokens).
A module or qbit extension of the UI API, as listed by the version endpoint.
JVM-local, in-memory session tokens accepted only from loopback requests.
Invokes UI API (`/qqq/v1`) operations from inside the server, with a given
user's session, with exactly the semantics of an HTTP client: the call is
a loopback HTTP request to the running server, so it passes through the
same session setup, permission checks, filters, logging and error mapping
as a request from the UI.
Application-test guard for "API = admin parity".
One invocable UI API operation, as described by its endpoint spec: method,
path template (relative to the version base path), whether it needs a
session, and the full OpenAPI operation (parameters, request body and
responses) for building tool definitions.
One in-process call to a UI API operation (see UiApiInvoker).
One file part.
The result of an in-process UI API call: exactly what an HTTP client of the
UI API would have received.
Finds HTTP routes bound under a UI API version's base path (e.g.
A streaming UI API response.
Lock thrown by ProcessLockUtils when you can't get the lock.
Definition of a Unique Key (or "Constraint", if you wanna use fancy words)
on a QTable.
Methods to help with unique key checks.
To make a list of unique key values here behave like they do in an RDBMS
(which is what we're trying to mimic - which is - 2 null values in a field
aren't considered the same, so they don't violate a unique key) (at least, that's
how some RDBMS's work, right??)
Internal native key material for write validation.
Privately constructed, schema-owned lookup shapes only.
Management process to unschedule all scheduled jobs (in all schedulers).
Action to update one or more records.
Helper for backends that want to do their updates on records grouped by the
set of fields that are being changed, and/or by the values those fields are
being set to.
Input data handler for the update action
Interface for the update action.
Output for an update action
An uploaded file, as clients see it (spec section 3.2).
An UploadRef (spec section 3.2).
Uploads for jobs and the assistant (spec section 3.2): a file is streamed
straight into the uploads storage table (no temp file) and gets an opaque
ref, bound to the uploading user, that expires (default 7 days; a job that
uses it extends it).
Stream the request's file into the uploads storage table as the caller.
Input for POST /uploads: the file's name, content type, and a supplier of
its bytes (read once, streamed).
Opens the request's file content.
Output of POST /uploads.
POST /uploads: stream a file into the uploads storage table and get an
opaque UploadRef (spec section 3.2) to pass to a job launch (uploadRefs) or
to the bulk-load operations.
Simple implementation of a Custom Permission Checker, that takes a permissionName
property, and just checks if the session has that permission.
UserPreferenceActionMetaData for session-scoped preference actions.
UserPreferenceActionRequest for session-scoped preference actions.
Transient action output.
Where a client displays an action and whether it targets a loaded row.
UserPreferenceChange for the session user's preferences.
UserPreferenceListMetaData for the session user's preferences.
Storage SPI for a preference section.
Provider context bound to the signed-in user.
UserPreferenceRow for the session user's preferences.
UserPreferenceRowChange for the session user's preferences.
Session-scoped user preferences: visibility, validation and trusted persistence.
UserPreferenceSectionMetaData for the session user's preferences.
UserPreferenceSectionResult for the session user's preferences.
Typed executor for the preferences API.
Core key-value preferences table metadata.
Registry and startup validation of user preference sections.
UserPreferencesMiddlewareInput in the user preferences API.
The session-scoped preference operations.
Output mapping shared by the preferences operations.
Shared contract and JSON handling for core preferences specs.
UserPreferenceValues for the session user's preferences.
QRecord Entity for UserSession table
Meta Data Producer for UserSession
Build a session for another user without changing the current session.
QRecord Entity for the UserSessionRefreshToken table - server-side storage
of OAuth2 refresh tokens, one row per userSession (keyed by sessionUuid).
Meta Data Producer for UserSessionRefreshToken.
Simple implementation of a Custom Permission Checker, that takes tableName
and TablePermissionSubType name properties, and checks if the session has
that table-permission-sub-type for the specified table name.
Model containing datastructure expected by frontend USA map
Generic widget for display a map of the us
Validate user writes against dependent choices, batching by dependency values.
Utility class to apply value behaviors to records.
Validate the min invalid input: '&' max value for numeric fields.
Behaviors for string fields, if their value is too long.
Utilities work values - e.g., type-cast-like operations
see https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Welford's_online_algorithm
Executor for the version endpoint: describes the API's semantic version,
features and registered extensions, so clients can check compatibility
before they sign in.
Input for the version endpoint: the middleware version being described.
Output interface for the version endpoint.
Response for GET /version.
GET /version - the UI API semantic version, features and extensions.
Converts a virtual field into ordinary query filters.
API response component representing a virtual field's metadata, extending the
base
FieldMetaData with queryability flags that indicate whether the
virtual field may be used as a filter criterion and/or included in query output.A webhook signing secret (Standard Webhooks format).
Signs webhook requests in the Standard Webhooks format
(https://www.standardwebhooks.com/).
A webhook request failed verification.
Why verification failed.
Verifies a signed webhook request (Standard Webhooks format, see
WebhookSigner).Follows ISO-8601 Standard, with Monday=1, Sunday=7.
Follows ISO-8601 Standard, with Monday=1, Sunday=7.
Field behavior that changes the whitespace of string values.
use a flatter mapping object, where field names look like:
associationChain.fieldName,index.subIndex
Typed OpenAPI schemas for the data of each widget type (the `widgetData` of
POST /widget/{name}), built from the backend's QWidgetData classes, and the
discriminated union over them keyed by the data's `type`.
Details about dropdown fields on a widget
Possible types for widget dropdowns
Executor for rendering a widget.
Middleware input for widget rendering.
Middleware output interface for widget rendering.
V1 response object for widget rendering.
Endpoint spec for rendering a widget via POST.
Possible values for widget type
Mark the fields supplied in an update as a policy wipe.