What JCM does today
This page lists what is built, what is built with limits, and what is not. Rows marked Planned, Not planned, Not built, Not finished or Client built are not available to use today. Every other row is.
2. Platform summary
What JCM is. A set of separately versioned add-ons for the Jmix platform that give a project's own entities
case-management behaviour: case numbering, workflow, queues, tasks, deadlines, documents, correspondence, search,
reports, dashboards and security scoping. The project writes ordinary Jmix entities; JCM attaches to them through
configuration files and keeps its own data in companion tables, never adding columns to the project's tables.
Thirty-one functional modules (jcm-*, each with a -starter), plus a BOM and test support. jcm new creates a new application with every component wired and a starter case type.
| Item | What is known |
|---|---|
| Language and runtime | Java 21 (applications compile and run on 21; the build's own Gradle, and checkJcmApi in it, may run on a Java 21 to 25 JDK) |
| Framework | Jmix 3.0.3, Spring Boot 4, Vaadin 25 (server-side web UI), EclipseLink JPA, Liquibase |
| Build | Gradle; artifacts group com.jcm, published to a Maven repository (local or private) |
| Configuration | YAML files, one folder per kind and one file per item, all read and checked at startup; a bad file stops startup naming file and line |
| Application server | Runs as a Spring Boot application with its embedded server, in the application's container image or as its jar (java -jar) on Java 21. Deployment as a WAR to an external servlet container is not built and not tested |
| Database | PostgreSQL 16: Built and proven. The sample's and the demo's full suites (test and e2eTest) passed on it with -Pjcm.db=postgres (Testcontainers) (the 12 cases of the HSQLDB-only GetNextLocksModeTest skipped there), and it is the database of every later proof: the image and demo stack check (scripts/test-image.sh) and the two-server run (scripts/test-cluster.sh, 70d16d6). suite.yml runs both suites on it on every push. HSQLDB is for development and the default test run only. Quartz's delegate follows the database (jcm-jobs). SQL Server 2022: built for it (the database must be created with a UTF-8 collation such as Latin1_General_100_CI_AS_SC_UTF8, which jcm-core's SqlServerCollation checks before any migration and refuses to start without, and run with READ_COMMITTED_SNAPSHOT ON and ALLOW_SNAPSHOT_ISOLATION ON; moments are kept in UTC, and SqlServerMomentPlatform refuses at startup an application's own DbmsFeatures bean that would bypass that, docs/deploy/README.md; Quartz's MSSQLDelegate) and proven by the release gate, ./gradlew sqlServerSuite -Pjcm.db=sqlserver (.github/workflows/release-gate.yml, by hand or for a v* tag): the sample's and the demo's full suites passed on SQL Server 2022 with a database collated Latin1_General_100_CI_AS_SC_UTF8 in CI. Proven on GitHub's amd64 runners only: the SQL Server image does not start under arm64 emulation. Under a UTF-8 collation a varchar(n) counts bytes, so long non-ASCII text that fits on PostgreSQL can be too long on SQL Server. Oracle and MySQL: Not tested. Jmix supports them; JCM has never run on them and jcm-core's SupportedDatabase refuses to start on any database but PostgreSQL, SQL Server and HSQLDB |
| File storage | Built: the local file system store (jmix-localfs) with jcm-core-starter, so every app has it; S3 (the Jmix S3 add-on, tested against MinIO in a container) and Azure Blob (JCM's own store over the Azure SDK, tested against Azurite in a container) with jcm-storage-starter, chosen by jcm.storage.kind, credentials from the environment, as.storage.probe round-tripping a file through the chosen store. Attachments and letters round-trip byte for byte through each (StorageS3Test, StorageAzureTest); each store's calls are bounded by settings (S3 5 s connect, 30 s a call; Azure 2 tries within 30 s). Moving existing files between stores is not built: changing away from S3 or Azure leaves earlier files unreadable, and opening one says so in a plain sentence. Google Cloud Storage: not built |
| Single vs multi-server | Built: several servers behind a load balancer with sticky sessions, on one database and one S3 or Azure store, each with JCM_SERVERS set; the sample's whole browser suite passes on two servers behind Traefik sharing PostgreSQL and MinIO (scripts/test-cluster.sh, passed at 70d16d6, and in the release gate's cluster job on GitHub: green in CI), with tests that one server's edit of a deadline duration and a letter template is used on the other, that two people pressing Get next on different servers get one record each, that a job run started from one server runs once (Quartz's clustered store; so does the email queue's job), and that a stopped server's users land on the sign-in page while the other's keep working. Limits: sessions are not replicated (a server that goes away signs its users out); the studio refuses editing when jcm.servers is above 1, and every server reports when it has not applied the newest publish (as.studio.applied); propagating a publish to running servers is planned. Two servers proven, on one machine, not more; rolling deployments have a documented caveat for jobs |
| Sign-in | Built: OIDC (jcm-identity-oidc-starter, tested against Keycloak 26 in a container; Entra ID and Okta given as configuration examples in docs/deploy/identity.md, not tested live) and LDAP (jcm-identity-ldap-starter, tested against OpenLDAP 2.6 in a container; Active Directory documented as configuration, never run). A provider's claim or group values become job roles and resource roles through checked files, jcm/identity/<code>.yml. MFA and password rules are the provider's; every sign-in form has JCM's per-username lockout, counted in the database; the database accounts left are break-glass accounts, shut by default. A provider sign-in never takes over an account it did not create (admin and the other reserved names refused from every provider; a database account must be linked first). SAML: not built |
| Health and operation | /actuator/health/liveness and /actuator/health/readiness for an orchestrator (status word only, no other actuator endpoint); the prod profile takes every setting from JCM_* environment variables and stops startup naming a missing one; every response names the server that answered (X-Jcm-Server) |
| Tenancy | One running application per customer; no tenant key (design decision) |
| Cloud | No cloud-specific code in any module. Built: a container image per application (Dockerfile: JDK build stage running the repository's Gradle wrapper with the production bundle, JRE run stage as the non-root user jcm, /data volume, prod profile, readiness health check; amd64 and arm64 through docker buildx), and the demo's compose stack (PostgreSQL 16, Keycloak, MinIO) that scripts/test-image.sh builds, starts, signs in to through Keycloak and stores a file in (docs/deploy/README.md); a new application gets the same from the scaffold (its Dockerfile and deploy/demo/compose.yml, built by scripts/test-new-app.sh). The two-server stack (sample-appeals/deploy/cluster/compose.yml, Traefik) is the shape for several servers. No deployment on a named cloud is tested; no Helm chart or Kubernetes manifests; production installer: Planned, owner, no issue |
| Browser support | Vaadin 25 supported browsers. Browser tests run in headless Chrome only |
3. Capability matrix
Status: Built, Partial (built with stated limits), Planned #n (open issue), Planned (catalogue only,
no issue), Not planned. "File" means a YAML configuration file under jcm/; "code" means project Java.
3.1 Case intake and records
In the contract: Configuration layout, Case screen, Case workspace: children, header and layout, Related cases, Duplicate detection, Recently viewed, Reference data, Seed data.
| Capability | Status | How configured | Limits |
|---|---|---|---|
| Case types over project entities | Built | jcm/case-types/<code>.yml, the entities in src/main/jcm/model/ (the build writes the classes and captions; ./gradlew jcmChangelog the changelogs) and the data roles in jcm/roles/ | Fixed when the application is built: a model or role change is a rebuild and restart, never a studio publish. Not in the model in this release (no issue; a hand-written entity needing one is framework/legacy only): enums (a reference list instead), embedded parts, many-to-many references, inheritance; dropping a whole entity is refused |
| Schema changes from the data model: each model change written as the next Liquibase changelog, checked against what has run | Built | Edit src/main/jcm/model/<Entity>.yml, run ./gradlew jcmChangelog, commit the changelog and schema.json | Additive changes are written as they are; removal and supported narrowing need marks. Only text-length and decimal precision/scale alterations are supported; narrowing refuses loss even under concurrent writes. A new required field without a supported default must be added nullable, backfilled, then made required with changed: true. Cross-family conversion uses a new nullable field and explicit conversion. Written changelogs are never rewritten |
Case numbering (patterns such as APL-{year}-{seq}) | Built | Case-type file | |
| Generated case screen, list and menu item, with no view code | Built | Case-type file (header, form, children, workspace, screen.add) | Supported section overrides need code; own views are framework/legacy only |
Case header fields and title placeholders through a reference to a shared record (applicant.phone), each shown only to someone who may view that field of the referenced record and left out otherwise; a record their rows hide is told as A record you cannot open | Built | Case-type file header.fields, header.title (${record.applicant.phone}) | One step only: a path through more than one reference, through a collection or naming an unknown attribute is refused at startup and at publish with a sentence; the label is the field's own caption. No query per field on the generated screens; a hand-built view with a narrower plan costs one read per reference attribute per drawing |
| Child records to any depth (parties, decisions, hearings) with their own tabs, panels and pages | Built | Case-type file children | Compositions only |
| A parent page kept current after its children change: closing a child's side panel reads the page beneath again, its moves and why they are held, actions, stage track, deadlines and timeline included, keeping the person's unsaved fields | Built | A field someone else changed meanwhile takes the saved value, with a notice; a record whose unsaved edits cannot be told apart safely is only redrawn; no CaseScreenContext hook for a refresh | |
| Intake of documents before a case exists (inbound document as its own case type, then file into or create a case) | Built | Case type plus queue buttons file-into, create-case | |
| Notes, retractable with a reason, never deleted | Built | Plain text, 4000 characters; retracting is a service call, with no screen control | |
| A read-only role reads every note and adds or retracts none; adding or retracting needs the update right on the record, row rules included, checked in the service, and the note box, Add menu entry and declared action's button follow it | Built | No separate note right: a role that may note without changing the record is a declared note action with authority: configured and roles, which has no retract; transition, automation and component notes are not asked | |
| Timeline filtered by kind: a chip per kind cycling shown, highlighted and hidden, with Reset, Show all and a count of what is hidden, kept per user across records and sign-ins | Built | Kept in the user's UI settings; nothing kept under anonymous or system authentication | |
| Related cases (typed links both ways, privacy for records the user cannot open) | Built | Link types in ref.jcm.link-types | Links keep string ids |
Linking two cases from a workflow move, a state's start, a declared action or an automation ({link: <field>, type: <link type>}), extension code through RecordActions.run; a person moving must be able to change the other case | Built on HSQLDB and PostgreSQL | link in a list of actions, naming a reference field to a case type and an item of ref.jcm.link-types | Case types only; links only to the case a field of the record holds; no unlink or note from a list; CaseLinkService not exported; not run on SQL Server |
| Duplicate detection (fuzzy text, date closeness, weights, threshold, dismissals remembered) | Built | jcm/duplicates/<binding>.yml | Chinese and Japanese titles compared as one word; dismissals not undoable on screen; unsaved records not checked |
| Recently viewed records | Built | Last 20 per user | |
| Reference data (effective-dated lists, parent-child lists, admin screens, seed files) | Built | jcm/refdata/ | Items never deleted, retired by end date |
| A reference list's items in their declared display order from extension code, each with its position | Built | ReferenceItems.items(listCode, onDate); RefItem.getSortOrder() | The order is by sort, then name, then code, as pickers show it; the order of a file's lines is not kept, so an item without sort (0) comes first |
A field declared with a reference list holds only that list's items active today, on every save path (screens, RecordOperations, system work, imports, seeds) | Built | list: on a model field, @RefListCode | Only an item the save sets is judged, so a stored item since ended stays until the field changes; rows of another list written before the check are logged at startup |
| Shared records: pick, create and edit one record many cases point at, from a case's reference field, under entity, attribute and row rights held at the save | Built on HSQLDB | A model entity, jcm/shared-forms/<Entity>.yml, and shared-record: true on the reference field | Model entities only, with no children; no removal on screen; references marked this way count for the "points at it" figure. A new record of an entity rows narrow for the person (as follows) is stored by the save of the record that refers to it, not by the panel, on the case screen, in a queue's create-case and add dialogs and in a document's fields dialog (SharedRecordFollowsUiTest); not so from a transition's dialog |
| A shared record's panel lists the cases that point at it, by case type, with chosen columns, as the viewer may read them | Built | cases: [{case-type, through, columns, sort, label}] in jcm/shared-forms/<Entity>.yml | Cases only, not child records; the first 20 of each list with a count; a list shows only to someone who may read the case entity and view the reference; no paging, heading sort, filter or export |
| Parties and contacts reusable across cases | Planned | Today parties are child records of one case | |
| Case merge with history kept | Planned |
3.2 Workflow and BPM
In the contract: Workflow.
| Capability | Status | How configured | Limits |
|---|---|---|---|
| States, transitions, roles per transition | Built | jcm/workflows/<code>.v<n>.yml | |
| Stages grouping states, each record's path drawn on every screen | Built | stages: in workflow file | |
| Workflow versions; records stay on the version they started on | Built | New file per version | No migration of in-flight records between versions |
| Conditions on moves: offer or hide a transition by the record, explain why not, choose the target by data with two of one name, run an action or an on-enter move only when a condition holds | Built | when:, because:, otherwise: in the workflow file, refused at startup and on publish with the file and line; shown in the studio's workflow area | The form rules' condition tree, no text form or field comparison yet; answered on the stored record with system reads; refused for every caller after beforeMove; fails closed; a form rule names all of the transitions of one name sharing a from state or none, and the one chosen answers its own form rules inside the move |
| Transition comments, confirmations, transition fields | Built | Workflow file (confirm:) | Comment max 1000 characters |
| Guards on entering a state (validation rules) | Built | jcm/rules/ with at: {entering: ...} | |
| A child's action that moves its case, whose entered state moves the case's children, leaves the child's own move standing | Built | The child mid-move is skipped by the cascade and noted on the case; its siblings are moved | |
| A child's move copying its own values onto its case or parent (an outcome's officer and date becoming the case's) | Built | {set: <field>, on: case | parent, to: {field: <child field>}} in the child's list | Same transaction; the parent's own rules and locks hold, a refusal refuses the move |
| A child type made only by moves (a follow-up task an outcome creates), shielded from manual creation | Built | created-by: moves on the child type | The move needs no create right of the mover; a person's own create is refused whatever their roles; system work and jobs still make them |
| Effects on transition, common cases: set a field (a value, today or an offset from it, now, the moving user, another field or a path through a reference, child rows joined into text, clear), create a child record, start or stop a deadline clock, end the assignments, move a related record, run an effect at its place, write a letter, email the assignees, the parties or a job role, add a timeline note, assign by rule; on a transition or on entering a state | Built | actions: in the workflow file, checked at startup and on publish with the file and line; shown in the studio's workflow area | Run in the move's transaction after the Java effects and before the state changes, any failure rolls the whole move back; as system work for the moving user (the transition's roles are the gate); an action's email is queued only once the move commits; when: on any entry; no loop, no outbound webhook; a letter template's ${workflow.state} is the state being left; anything else stays a WorkflowEffect (code) |
| Effects on transition beyond the file actions (code run in the transition's transaction) | Built | Java bean referenced by code (effects:) | No embedded script language by design |
| Child workflows (a decision or hearing with its own life) | Built | binding: case.appeal/decisions | |
| A parent's move guarded on its children's own workflow states, held against concurrent child writes | Built | when: with exists or count on a child type and state in its where; jcm.workflow.hold-wait | A child write under a guarded parent waits at most the hold-wait, then is told someone else's change; SQL Server needs READ_COMMITTED_SNAPSHOT ON |
| Appointments: book, reschedule, reassign, confirm, cancel and decline a resource and people from the generated record screen, coupled to a workflow move with no partial result; proposed appointments reserve; whole business days; two simultaneous bookings of one interval never both succeed | Built on HSQLDB, PostgreSQL and SQL Server | jcm/resources/<code>.yml, the six entries in a declared action's do:, control: appointments, Appointments in Java | On a case or any child record (each child its own bookings, read by the child's row rules); one open appointment per kind per record; no recurring series, portal booking, iCalendar or provider calendars or resource pools yet; free slots are booked through Resource availability, below |
| Agenda: what one resource has booked over a day or up to 31 days, by declared name, as a page and over the booking dialog (returning to it with what was typed kept); cancelled told apart from held by more than colour; links only to records the person may read, the rest "Booked" with nothing of the record in the page; who may open a resource's agenda checked on the server | Built on HSQLDB, PostgreSQL and SQL Server | agenda-roles in jcm/resources/<code>.yml, jcm-agenda-user included by a role file for the page jcm/agenda; the dialog's "See what is booked" needs nothing written | Shows only: no provider calendar or recurrence, and free slots are picked in the booking dialog's slot picker, not here; one resource at a time; told in the person's own zone; an appointment moved to another resource or time is shown where it now is, not where it was |
Booking from slots: a slot ask offers the free slots of the holder another input names as a keyboard-first week in the booking dialog; book and reschedule from a slot, checked again under the holder's locks so two bookings of one slot never both land; day: exclusive; a party held one at a time; reassigning a person only to a matching free slot; slots: required; slots read Booked and are not moved or removed while booked | Built on HSQLDB, PostgreSQL and SQL Server | type: slot with of and holder in a declared action's asks, slot:, day: exclusive and party: on book, slot: on reschedule, participant: on reassign, slots: required in jcm/schedules/<code>.yml; Availability in Java | A free-hand booking names a slots-required resource refused at the line, people only as it runs; no group booking (one appointment for several records) yet |
| Adopting an appointment booked at a time into its matching slot, so reassignment enforces the slot; a move to a slot only the appointment itself occupies | Built | {adopt-slot: hearing, of: sch.hearings} (optional participant:); reschedule: {slot:} | Same holder, exactly the same start and end; only the link is written, status and reservations kept; one record a transaction (run it over the records for a migration) |
| A list of a schedule's slots, free and booked together, from today onward (a floor no setting removes), with holder, day, time, state and the booked record | Built | slot-list: {days: 28, roles: [...]} in the schedule file; the Slots page (jcm/slots), role jcm-slot-list-user | The record is named only to someone who may read it; a resource's slots need its agenda; at most 92 days and 1,000 rows; no sort, export or booking from the list |
Moves of related records on entering a state (on-enter), checked before writing, loop and depth limits | Built | Workflow file | Five levels |
Case moves made only by children (related-only) | Built | Workflow file | |
Moves made only by a queue button's then, after its work (queue-only) | Built | Workflow and queue files | |
A move from every open state (from: any, except) | Built | Workflow file | |
Exception moves: a required reason, warning and confirmation naming both states, a mark in history (exception: true) | Built | Workflow file | Made from the record's screen only: not from a board, a queue button, a seed or a deadline action |
A supervisor's "Correct status" to any state, with a reason; no side effects unless on-enter: true; clocks follow or keep (correct-status:) | Built | Workflow file | A person only, never system work; no bulk correction; leaving a final state needs from-final: true |
Exception moves report for an oversight role (jcm-workflow-oversight) | Built | Role grant | Lists only records the reader may read; newest 500 between two dates |
Declared actions: actions: in the case-type file with asks, roles, when, authority: configured | Built | Case-type file | A button on the record screen and RecordActions; queue buttons (2.4) and REST (2.8) do not call it yet |
One holder among siblings: single: on a child type and a declared action with choose, replacing the holder in one transaction under the case's row; a single with no instead only refuses a second holder and no action chooses it; several singles on one child type, also on one attribute with their own values, each narrowed to the rows its among names | Built | Case-type file | No database constraint yet; writes to such a child type queue on their case; not on a case type's own records or shared records |
At least so many children: min: N on a child type refuses any removal or move that would leave a parent fewer rows, whoever makes it, judged once at commit and held against concurrent removals | Built | min: (1 to 1000) on the child type in the case-type file | Only removals are refused (a parent may be saved with fewer); not on a case type's own records or shared records; no maximum and no database constraint; a write that bypasses the data store is not covered |
A role-scoped assignee on a child type: each row held by one account drawn from named resource roles, kept in a user reference field of the row, offered by the form field, a declared action's user input and the queue's assign button, and refused on save for anyone else | Built | assignee: {field, roles} on the child type; ChildAssigneeChoices from Java | Active accounts holding a role by database assignment only (not a role granted by a sign-in provider); separate from the case's assignments; the picker reads accounts as the system |
Move chosen children to a new record beside the parent: a declared action with a children input and transfer: makes a sibling of the parent's type under the same parent and moves the chosen rows to it in one transaction, all or nothing, chosen from a table of the rows the person may move | Built | asks: {type: children, of: <child>} and do: [{transfer: <input>, fields: {...}}] on a child type's action | The new record is a sibling of the same type; a new case is not made this way |
| Split a case along chosen children into a new case of the same type: numbered, its fields copied, its workflow started once the rows are under it, assigned to the caller or the source's assignees, scoped as the source | Built | transfer: on a case type's actions with copy, fields, assignees | All of it or nothing; the source keeps its min:; references between moved and unmoved records are left as they are |
A sibling drafted from a child's screen: a declared action with create ... under: parent and draft: true opens the type's generated form with a reference already chosen and saves nothing until the person's own Save | Built | draft: true on a create in a declared action; RecordActions.draft from Java | Must be the only entry in do, with no when, asks or state on it; saved under the person's own rights; the picker of a reference shows the display name its list gives |
"May I" and running a declared action from Java: RecordActions.may and run, Verdict, Outcome, idempotency keys with input hash and expiry | Built | Exported RecordActions, jcm.actions.key-days | allowed: false always means run refuses; true may still refuse. Keys proved on HSQLDB only so far |
A declared action on the record screen: a button for those allowed, a dialog from asks, the refusal in plain words | Built | Case-type file | Labels come from input names; a user input is a username field until option lists; not in the queue's split view |
| Concurrency (optimistic lock on each instance) | Built | ||
| Workflow log and audit screen | Built | Log order relies on server clock; log does not record definition version | |
| Workflow diagram | Built | Drawn from the file by stages, with a record's path | |
| Edit a workflow in the UI (states, transitions, stages, who may make each move) | Built | jcm.studio.edit.workflows in a lower environment | Form dialogs on the diagram, not freehand drawing; a change that could strand records becomes a new version; no condition builder; production read-only by default |
| Timer transitions and escalation | Planned | Contract: "Not here yet: timers and escalation" | |
| BPMN 2.0 / BPM engine | Planned | BPM adapter in catalogue, no issue. Jmix BPM (paid add-on) requires a reviewed framework adapter, outside the supported project API | |
| Parallel branches within one record's workflow | Not planned | One state per record; parallel work is modelled as child records with their own workflows |
3.3 Work distribution and queues
In the contract: Queues and inbox, Assignments, Assignment rules.
Queue date availability: configuration can limit a queue with inclusive ISO yyyy-MM-dd start/end
dates, using the application clock. Removing a key clears its limit; empty/null values and invalid ranges are
refused. Fresh reads and actions enforce the interval with existing permissions; inactive queues disappear from
Inbox on navigation/reload. Already rendered rows are not pushed away at midnight. Runtime coverage uses parser,
service, real-grid and browser tests. Dedicated clock-spy service/grid contexts close after their test classes;
the sample's ordinary test task conservatively caches at most eight Spring contexts, at the cost of recreating
evicted contexts. These test-resource policies are not runtime settings and make no product memory-leak or
complete-suite heap guarantee. Test support also destroys newly published matching Jmix UI fixture services
following Jmix teardown. Public destroy-event regressions cover this fixture lifecycle; failures before service
publication remain outside its ownership, and concurrent signal transaction fallback behavior is unverified
(testing). This does not change application capabilities. Studio Basics edits optional dates and removes cleared keys; invalid ranges
and malformed keyboard input remain for correction and cannot publish; malformed input never clears a bound. Gallery date labels retain future and expired queues. Editing remains
off by default and requires the editor role; UI and keyboard tests cover publication, clearing and refusal.
Prompt calendar closing and reopening preserve access to surrounding controls; browser regressions cover both date fields
and subsequent keyboard editing.
| Capability | Status | How configured | Limits |
|---|---|---|---|
| Writes of a child type serialized on its case, so a value of the case derived from its children (by a lifecycle hook) never goes stale under concurrent writes | Built | hold: true on the child type in the case-type file | Every create, update, delete and re-parenting of the type's rows holds the case's row: writes to one case queue (up to jcm.workflow.hold-wait for a person on PostgreSQL and SQL Server); no Java lock call |
| Queue column and date filter for a record's booked appointment time (start, end, room, people) | Built | appointment-<kind>-starts (or -ends, -resource, -participants) in a queue's columns, sort and filters | Read live from the appointments, never stale; people shown only to whoever may open the resource's agenda; moments sort and filter, the resource and people do not |
| Queues over cases or child records with state, assignee and condition filters | Built | jcm/queues/<code>.yml | |
| Queue filter chip on a user field other than the assignee (a reviewer, the responsible officer), of the row or of a record above it: Me, Nobody or chosen people | Built | filters: [technician] naming a type: user field; workOrder.dispatch.coordinator through the row's parents | People offered: the role holders of a declared child assignee field, else the accounts the reader may read, at most 500 by name (the chip says when there are more); only for a reader who may read the accounts with no row rule on them and view the field; a slice is judged by the people it names |
| Filter chips on a queue of child records by a field of their parent or of any record above it (the case's status or date, two or more steps up) | Built | filters: [appeal.status, appeal.filedOn] on a queue over a child type, party.appeal.status on contacts under parties; a column and sort on the same path | Date and reference-list fields only, through the row's parents only; a hidden parent's rows are never rows of the queue; not offered to someone who may not view the field |
Queue where: the condition tree in the database, the same rows as in memory, a fact refused at startup | Built on HSQLDB; PostgreSQL and SQL Server await the release gate | where: in jcm/queues/<code>.yml | Text ignores case in the database and is exact in memory; a compare of two fields needs two dates |
| Inbox with tabs and count badges | Built | inbox in jcm.yml | |
| Columns from child records (latest, list, count, exists), a child's own workflow state among them | Built | Queue file; show: row-state on a latest or list column | These columns do not sort; row-state only on a child type with a workflow of its own; none: captions a row with no child; a state in a column's where is the child's own |
| Queue membership by the latest child only (its state or a condition), with rows that have no child | Built | latest-child: [{of: hearings, by: scheduledAt, states: [...], or-none: true}]; by left out is creation | The latest the person may read: a hidden newer child neither counts nor shows by absence; no use of the queue without read of the child entity; by a date, moment, number or text |
| Queue columns and a condition for document facts: a document of a type exists, a new document since the person last opened the record | Built | {document: EVIDENCE, key, label}, {new-document: any, key, label}; where: {documents: {new: true}} | Counts only documents the person may read; "last opened" is the record's detail view; the columns do not sort; the older documents: {present} leaf weighs the type restriction only |
| Columns from child records (latest, list, count, exists) | Built | Queue file | These columns do not sort |
| One queue over several case or child types, with the case type as a column and a chip | Partial | over: [<queue>, <queue>] in place of binding, columns every member lists plus case-type, filters: [case-type] | Rows, counts and access are each member's; merged by the attribute the members share as their sort (to row 1,000, settable; one member chosen pages straight through), else member after member; no search, export, buttons, Get next, board, heading sort, dashboards or studio editor for it |
| Sorting, paging, multi-select, filter panel, per-user column settings | Built | ||
Sort by a column of a child's parent path, a reference's sort-by, the case number, assignees or workflow-state place, and a combined column joining two to four fields in one heading | Built | columns: entries {column, sort-by} and {combined: [...], separator, key, label}, sort: in the queue file | A page sorted this way is read in two steps; rows with no value come last; a heading the person may not view does not sort; cost grows with matching rows |
A queue column on a reference list field of the row's parent (appeal.status on a queue of parties): the item by its name, the field's caption or a label, sorted by name or by the list's order (sort-by: sortOrder) | Built | columns: entry appeal.status or {column: appeal.status, sort-by: sortOrder} | Proven on the parent of a child type with or without a workflow of its own, and through a record the row refers to (party.agency on contacts); every path ending on a reference is fetched with that record's name |
| Filter chips on a queue: state (or row state), assignee, a date range, or a reference list item, narrowing only and checked on every read | Built | filters: [state, assignee, <date>, <list field>] in the queue file | Not offered for an attribute the person may not view; a request naming a state the queue does not list is refused |
| A New button on a queue that needs no selected row: opens a case type's form, saves it numbered and with its workflow started, hides from people who may not create it, then reloads and selects the new row when it falls in the page | Built | new: <case type> in the queue file's actions: | Refused on a queue over a child type; not with then, target-then, copy or on-record |
| Work buttons and bulk actions (move, assign, add child, set fields, file into, create case) row by row with a report | Built | actions: in queue file | |
| Board (kanban by stage or state) with keyboard Move to | Built | board: | 50 cards per column shown, true count displayed |
| Split view (record beside list, goes on to next row) | Built | ||
| Get next with claims (two people never get the same record) | Built | next: | Claims lapse after 30 minutes (setting) |
| Queue buttons on the record's own screen | Built | on-record: true | |
| Queue start and end dates (a queue offered only between two dates) | Built | start/end (ISO yyyy-MM-dd, inclusive) in the queue file or the studio's queue editor | The application clock's day, checked on fresh reads and actions; rows already shown are not removed at midnight |
| Assignment to users and groups with history and audit screen | Built | Groups need a QueueGroupResolver bean for my-groups (code) | |
| CSV export of a queue | Built | Exports the whole queue, with permissions, scope and formula protection | |
| Skills-based or load-balanced automatic routing | Built | jcm/assignment-rules/<code>.yml (by a field's value to a user, a group or a job role; round-robin or least-work, optionally a skill), run by a workflow {assign: <rule>} action or a queue's assign-rule: (an Assign by rule button); skills per user on the User skills screen (jcm-assignment-rules-admin); read-only "Assignment rules" studio area | Never replaces an assignee; job-role holders are the users holding its resource roles by database role assignment (not roles granted only by a sign-in provider), able to sign in; least work counts the binding's open records; Get next does not route by rule; groups are items of ref.jcm.assignment-groups, membership still the app's QueueGroupResolver; other routing stays code (QueueGroupResolver, a hook or a job) |
| Workload by person view | Built | DashboardReportsRole; any queue the user may use | Overdue is a running deadline clock past due; oldest by the case's opened date; names only where the queue shows assignees |
3.4 Tasks
In the contract: Tasks.
| Capability | Status | How configured | Limits |
|---|---|---|---|
| Tasks for a user, a group or nobody on a record | Built | Closed tasks never reopened | |
| Task templates created on entering a state, with due days and assignee rule | Built | jcm/tasks/<code>.yml | Due days are calendar days |
| My tasks view, task list on the record, tasks on the timeline | Built | ||
| Checklists, task dependencies | Not planned |
3.5 Deadlines, SLA and calendars
In the contract: Deadlines and SLA, Calendar and hearings.
| Capability | Status | How configured | Limits |
|---|---|---|---|
| SLA clocks started and stopped by workflow states | Built | jcm/deadlines/<code>.yml | Due date moves only as the policy or a person says |
| SLA clocks on a child record with a workflow of its own (a task-like child timing out), its breach moving the child | Built | binding: <case type>/<child type> on a policy, on-breach: {move: ...} | Child types with a workflow only; move and notify on breach, no reassign (a child has no assignment); in the work dashboard's deadline lists, read by the child's row rules; not in deadline alerts, the case's timeline or screens, and no from: {delivery} |
| Clocks in hours, and in office hours by a calendar's opening times, across weekends and daylight saving | Built | duration, calendar, warn-before; jcm/calendars/<code>.yml | Precision is the action job's cadence; sub-minute left out. Proved on HSQLDB only so far |
| Clocks from a date field, from another clock's due date (waiting, pausing and moving with it), or the earliest of several dates, with a waiting state | Built | from, from: {clock:}, if-empty, due: {earliest-of:}; as.deadlines.waiting | A date moves a record with no marker row |
| Clocks dated by an appointment's start (N business days before a booked hearing), re-timed when it is rescheduled and struck when it is cancelled | Built | from: {appointment: <kind>}, due: {appointment: <kind>, minus: {days: 3}} | The record's own open appointment of the kind; a decline changes nothing; a booking against a firing deadline action may be told the conflict sentence |
| Clocks that move: recalculated on a field or a holiday, extended, paused and resumed, with a ledger | Built | recalculate-on, pause-when, clock actions; Clocks from Java | Occurrences move with the date in one transaction; actions on a clock stay reassign, move, notify until 9.4 |
| Business days, weekends, holidays list | Built | ref.jcm.holidays additions | Saturday and Sunday fixed as weekend unless the calendar bean is replaced (code) |
| A clock's due date kept in a field of the record (sortable, filterable, letter-readable), and a duration chosen by a field's value or less whole-number fields | Built | due-into: <field>; duration: {days: 7, by: category, cases: {URGENT: 3}, less: [daysTolled]} | The newest clock's date, empty while paused; written past the data store with no field history (the clock's ledger has it); the amount is decided when the clock starts |
| Business-day addition and subtraction: the first business day after (before) the start is day one, from any day (Saturday plus one is Monday) | Built | BusinessCalendars, due entries' minus/plus; a duration's first day by counts: {first-day: ...} | A duration keeps rolled unless its file says excluded; counts needs a calendar |
| Durations editable at runtime by an administrator | Built | Admin screen | Applies to clocks started afterwards |
| Status (on track, due soon, overdue, met, missed), badge on the record, deadline dashboard tiles | Built | Policy warn-before-days, dashboard file | Badge counts business days even for calendar-day policies |
| Deadline alerts to assignees (in the dashboard) | Built | Scheduled job calling DeadlineNotifications.raise() (code); with notifications installed, the deadline-due rule (the sample's) | Standalone dashboards only; guarded when notifications is installed |
| Escalation on breach (move, reassign, notify supervisor) | Not finished | Optional actions and notifications starters | Disabled scheduling by default |
| Hearings calendar: rooms, participants, no double booking, working days, week view | Built | Rooms in ref.jcm.rooms | Server time zone only; working hours not checked; participants typed as usernames; no time zone shown |
| Multiple business calendars (per region or office) | Built | jcm/calendars/; calendar: {by: <field>}; BusinessCalendars from Java | Each decides in its own zone; a clock with no calendar still uses the framework bean |
| Resource availability, slice 1: a person's or a resource's regular week kept as data, bookable slots made weeks ahead by a daily job, an Availability page to edit weeks and slots, with Free, Busy, Past and Removed told apart | Built (slice 1); proved on HSQLDB, PostgreSQL and SQL Server | jcm/schedules/<code>.yml (code sch.), job jb.slots.generate (needs jcm-jobs), Availability page, role jcm-availability-user, jcm.availability.keep-days | Only keeps slots: booking from a slot, a slot picker, slots: required and group booking are later slices; a slot taken by any booking reads Busy |
3.6 Documents and attachments
In the contract: Attachments, Mailbox intake, File storage, File automations.
| Capability | Status | How configured | Limits |
|---|---|---|---|
| Upload documents on records with document type and description | Built | Types in ref.jcm.document-types | |
| File type allow-list checked against content (signatures, real Office packages) | Built | Fixed list of 22 extensions, audio and BMP among them; an installer named .doc passes as a compound file | |
| Size limit | Built | jcm.attachments.max-bytes (default 25 MB), per binding max-bytes in a document policy up to jcm.attachments.max-bytes-ceiling | Streamed, so a recording need not fit in memory |
| Most documents a record holds (one source file on an intake record), on every path but a letter filed, two at once taking turns | Built | max-documents in the binding's document policy | Counts every document not withdrawn that people, imports, copies and moves add, scans pending, failed or infected included, so a full record shows a person it holds documents they may not see; a letter filed takes no place and is never refused; one limit for the record, not one per type; a lowered limit removes nothing |
| SHA-256 kept per file | Built | ||
| Withdrawal with a reason (never deleted), moves between records kept in both histories | Built | ||
| Correcting a filed document's type from the Documents list: file, bytes and upload details kept, policy and rights checked again at the save, each change in the history with who and both types | Built | The types a policy offers by role and state | Not for letters, withdrawn files or files not through their scan; a type the policy does not offer the person now cannot be left; a type cannot be cleared to none, from the screen or through Documents.setType; a lost race is refused, not merged |
A record's field naming one of its case's documents at one revision (model type: document, optional types): a picker on generated forms with each file's revisions and SHA-256, every save held to the record's own case, readable, not withdrawn, scanned and of an accepted type, and the revision leaf for the moves that depend on it | Built | The field and its types in the model file; when: {revision: <field>} on a transition | A document is one revision and nothing replaces it; no preview and no access log; a named document may be withdrawn or moved (the leaf then fails) but not corrected into a type the field refuses; where files are scanned only a passed one is named; shown as file, revision and SHA-256 wherever the value is formatted, and as nothing to who may not read it, by its own restriction or by their row rules; a named document its saver may not read is kept by their save and cannot be changed by them |
| Files kept on the server's disk, in S3 or in Azure Blob | Built | jcm.storage.kind (JCM_STORAGE: local, s3, azure) with jcm-storage-starter; the bucket or container and its credentials from the environment | S3 tested against MinIO and Azure Blob against Azurite, both in containers; no run against AWS or Azure themselves. Existing files are not moved when the kind changes. Google Cloud Storage not built |
| Upload policy per binding: accepted files, size, types by role and state, closed state, help, columns | Built | jcm/document-policies/ | Publishable under jcm.studio.edit.document-policies; no studio screen in words yet |
| Two-level document types | Built | parent: under ref.jcm.document-categories | |
| Required upload on a form or a transition, usable before first save | Built | upload field on a case form | Case forms only |
Exported documents API, documents condition, document.* events | Built | Documents, {documents: {...}} | Case records only |
| Letters filed as documents with a type, old and new | Built | document-type on a letter | Restricted letters need a restricted type, else they stay on their tab |
| Custom fields on a document, by type, with list columns | Built | extends: document, extension-forms | Edited on the Documents card; no action kind yet (5.10) |
Documents that arrive by email: one record per allowed attachment of each message in an IMAP mailbox, stable message and attachment keys and the server's receipt time (received-at) in a declared date, date-time or text field (a date takes its day in the server's zone), everything not allowed reported and the message held, never acknowledged in silence; retried without duplicates, moved only once its receipt stands and its UID is confirmed; work for a person on the attention list | Built with limits | jcm/mailboxes/ with jcm-mailbox-starter; the connection in jcm.mailbox.connections.<name>.* | IMAP with a password over TLS only (no XOAUTH2, so not Exchange Online yet; no Microsoft Graph); no body stored; no matching to existing records; a reported message is not retried from the held folder; a server must offer UIDPLUS; proven against GreenMail and Dovecot, not yet against Gmail or Exchange. See Mailbox intake |
| Virus scan state: quarantine, retry, nothing opens unscanned, stuck scans surface | Built with limits | DocumentScanner bean | No scanner ships: ClamAV is planned. Scans run as a job, so a scanner needs jcm-jobs |
| Versions, in-browser preview, download log | Planned | Downloads are never rendered in the browser today | |
| Integration with an external DMS or records system | Not planned | ||
| Full-text search inside documents | Planned | Full-text search in catalogue, no issue |
3.7 Correspondence and email
In the contract: Correspondence, Email.
| Capability | Status | How configured | Limits |
|---|---|---|---|
One placeholder form in file text: notes, confirm, because, rule messages, letter subjects and bodies | Built | ${record.path}, ${case.number}, ${workflow.state}, ${transition}, ${user.name}, ${today}; checked at startup and on publish with the file and line | Filled with the access of the person at work, inserted as text in one pass; a note is fixed for all readers, so its template is the author's disclosure; no expressions; the old {case-number} note form reads with advice for one minor; ${input.x} waits for declared actions |
| Letter templates with placeholders, editable at runtime, checked on save | Built | jcm/letters/<code>.yml, admin screen | Fixed placeholder set |
| Letters stored with a PDF, never edited or deleted, on the timeline | Built | Built-in PDF font covers Western European text only | |
| Delivery evidence: what became of each piece (mailed, held, returned, failed, voided, delivered) recorded apart from the PDF in an append-only ledger; a clock started on mailing, a guard on it, an automation on a return | Built | Record outcome on the Letters tab for jcm-delivery-recorder, DeliveryRecorder.recordAs; from: {delivery: ...} on a policy, {delivery: ...} in a condition | A mailing recorded in error is struck by recording VOIDED, never edited; a provider's ACCEPTED is not delivery |
| A read-only role reads every letter and document and writes none: generating, writing or regenerating a letter, adding a task, working on a questionnaire, withdrawing a document and adding a child record need the update right on the record, row rules included, checked on the server, and the standard controls follow it | Built | No separate right: a role that may write a letter without changing the record is a declared letter action with authority: configured and roles; a transition's or automation's work is not asked; email has its own right plus read, and closing a task its assignee plus read | |
| Word (DOCX) letter templates filled through Jmix Reports, kept as DOCX and PDF | Built | Report with a DOCX template, reportCode on the letter template | |
| A report whose input is a record of a case or child type, run from Jmix's Run report dialog or from a record action, the record made from the dialog with "New <caption>" when it does not exist yet | Built | The parameter's entity, or do: [{report: <code>}] in a declared action | The picker reads only records the person may read, shown by name; a parameter naming a lookup screen keeps it; lists of records (ENTITY_LIST) keep Jmix's own field; the action is the whole list and only hands a document; New is offered for a case type only (not a child type), to who may create it, with the case type's own form |
| Email of letters through a queue with retry and delivery status | Built | spring.mail.*, sender role; JCM sends the queue every minute (a clustered Quartz job with jcm-jobs) | Up to 20 addresses; delivery outcome reads "unknown" once the queue is cleaned |
| Merge-field picker, conditional and repeating blocks in plain templates | Built on HSQLDB | ${if}, ${each}, the template screen's picker | No ${else}; a condition reads the record's own fields; no filter or block inside ${each}; the picker lists fields of the record, not through references |
| A filtered child list in a Word cell, in a stable daily shuffle | Built on HSQLDB | values: on the template, a text parameter on the report | Letters only; a report needing it is not offered on the record's screen |
| One document from a cover chosen by data or channel, the letter, stored PDFs, converted Word files and static PDFs, with a shared letterhead | Built on HSQLDB | compose:, jcm/letterheads/<code>.yml | Joined after commit, so the letter has no PDF for a moment; a Word file holding what would print wrong is refused by name (tracked changes, hidden text, text boxes, equations, drawn shapes, most fields; see the contract), which may be many real documents, and long ones are refused by a heap-based limit, with an office-grade DocumentConverter as the way out; PDFs only besides Word |
| Regenerate a letter for every channel in one step | Built on HSQLDB | Regenerate on Letters, LetterService.regenerate | One addressee's letter at a time; filled as the person may see it, which it warns of |
| Parties and one audience | Built with limits | parties: in the case-type file with child, through, where, name, email, postal, phone, channel (a field, or {field, values} mapping the application's values to channels), do-not-contact, never-contact, confidential, copies; one to: of assignees, parties, {party}, {job-role}, {group}, {user}, {address}, {list}, {code}, except: actor on send and email | Notifications do not read to: yet; format is read and chooses nothing; the picker does not offer a party read through a reference; proved on HSQLDB alone |
| Communication record | Built with limits | jcm_Communication per recipient and channel, jcm_CommunicationBody per envelope, the communications workspace control, CommunicationLog | Old CaseEmail and LetterEmail rows stay on their tables until they are moved; resend and tracking are not built; no REST or exported read; proved on HSQLDB alone |
| Delivery evidence from application Java | Built; proved on HSQLDB, PostgreSQL and SQL Server | com.jcm.correspondence.api.Deliveries: record, recordAsProvider, mayRecord, pieces, piece | The same permission and read rules as the Letters tab; no REST endpoint; a provider's caller answers for who the provider is |
| Daily print batch: pick, split, name, count pages, ZIP with a manifest, role-gated logged download, void before sending, mark as sent, send to a connector | Built; proved on HSQLDB, PostgreSQL and SQL Server, the screen in a browser on HSQLDB | jcm/print-batches/<code>.yml, the Print batches screen, role jcm-print-operator, PrintBatches, PrintConnector | Splits by case type, template, party and envelope size, not by a field such as a region; always one ZIP; no schedule in the file (a job calls PrintBatches.build); no studio page |
| Automated email sent when its turn comes, one message per address for one text (a letter per addressee goes to each alone): approved attachments pinned by hash, holds of the template and the case type asked again at dispatch and at every retry, obsolete notices, bounded retries and waits, one send across servers, outcomes committed before anything listening is told | Built with limits; proved on HSQLDB, PostgreSQL and SQL Server | email: in the letter file (attach, accept, max-bytes, holds, obsolete); email.holds in the case-type file; emailed-document-types in access.yml; jcm.email.dispatch.*; `email: {hold-max-hours | keep}in the case-type file; a person holds, releases or voids a piece withjcm-delivery-recorder; a parked notice and a hold overdue show on Work needing attention (email-dispatch`) |
| Recipient-aware letters | Built with limits | for:, ${recipient.*}, render-as, read-roles on a letter template, send with channel and required, system-rendered-templates in jcm/access.yml, which may pin each template's readers, the role jcm-parties-confidential; a no-person automation or clock may send, letter or email a pinned template | Only a pinned template is written with no person at work; a system render goes to none of the application's people who may not read it (NOT_A_READER, asked again at dispatch). A Word letter cannot render as the system (a report runs as the person), and one written for each addressee has rules of its own (next row); print stands at PREPARED until a print batch holding it is marked sent; no sms or portal provider; required overrides do-not-contact, a deceased party's too, and never never-contact; a party's channel map refuses an unmapped value with UNMAPPED_CHANNEL; proved on HSQLDB alone |
| Word letters written for each addressee from a designed master, including a master that prints the addressee from a field of one of its own bands, left unchanged | Built with limits; proved by class on HSQLDB, PostgreSQL and SQL Server | report: beside for: on a letter template, recipient-on-band: {band, fields} for a band-printed addressee, with language, variants (each naming its own master and its own ordered inserts), version, complete-for, compose: and send; the master prints ${Root.recipientName}, ${Root.recipientAddress}, ${Root.recipientSalutation} and ${Root.recipientLanguage} and declares nothing for them; jcm.correspondence.report.max-addressees | Written by a person only: no job, clock or automation, no render-as: system; whoever makes the move or presses the action needs jcm-reports-user and a role the master names, and a move over REST cannot write one; the whole send is refused when the writer cannot open the record or may not read an addressee's row, name, salutation or printed address (a letter of text prints that empty instead); at most 20 addressees for one send unless the property is raised, refused and never trimmed; the runs of one send share reports.max-seconds; only someone who may read the party lists or opens its letter; asked again by a declared action or the Letters list, an addressee who already holds an unvoided piece is not written again and the outcome says so, while a move, Regenerate and a void write again; nothing of the addressee beyond the four values, and no data set may name them; a cover written by a report is refused on such a letter; the stored Word document is the only evidence of the master; no preview of the Word document |
| Letters in each addressee's language | Built with limits | language, variants and version on a letter template; language: {field, required, default} on a party | A variant is a letter file of its own with its own text, covers and files; no fallback: a language the letter does not hold, or none recorded without a party default, refuses the letter for every addressee; a required language with no variant is refused at startup at the file and line; the letter keeps its language, variant, template version and revision; the application's own language values are not mapped (the stored value or a reference's code is the language); format chooses nothing; the PDF itself is not marked with the language; a cover of a letter that says its language must say the same; variants are not offered in the picker; proved by class on HSQLDB, PostgreSQL and SQL Server, no full gate |
| Complete destinations before a letter is prepared | Built with limits | complete: {print: <condition>, email: <condition>} on a party; complete-for on a letter template | A condition on the party's stored record, asked when the letter is prepared, never at save; a required notice with an incomplete addressee is refused and keeps nothing, an optional one records INCOMPLETE_DESTINATION; complete-for holds for sends, written letters and letters made again, and leaves no addressee out; preferred with no wish does not move from an incomplete email address to print; no postal deliverability check; proved by class on HSQLDB, PostgreSQL and SQL Server, no full gate |
| Ad hoc email from a case | Built with limits | parties: in the case-type file, or its shorthand email.recipients (a child type's address attribute, or the case's own), the jcm-email-adhoc-sender role, email.ad-hoc-per-user-per-hour in jcm.yml | Only addresses the case holds, under the sender's read rights (no typed or outside address); plain text only; up to 20 addresses, 10 attachments and 20 MB; no templates, threading or replies; the outcome is kept once sent or failed, an email the queue cleaned up before that reads "unknown"; the hourly limit is approximate across one user's concurrent sessions |
| Inbound email to the case with threading | Planned | ||
| SMS | Planned | ||
| E-signature | Planned |
3.8 Forms, validation and rules
In the contract: Validation rules, Record validators, Record lifecycle, Questionnaires and wizard.
| Capability | Status | How configured | Limits |
|---|---|---|---|
| Generated forms with sections | Built | Case-type file form | |
Form rules: shown, required, read-only when, over a field against today or another field, child rows and the user; defaults; clear when hidden; lists filtered by another field, with options one parent has or options shared by several through membership rows; a read-only field holding the parent of another field's item (parent-of), live on the form and set on every save; facts | Built | Case-type file | Answered on screen and enforced on every save |
| Case header alert while the case has a child or grandchild row matching a condition (an open request with an unaccepted item) | Built | header.alerts when: "has <child> where (...)" or nested exists | Counts only the child rows the viewer reads; a child field they may not view shows no alert; redrawn with the screen's controls, not pushed from other sessions |
| Copy from an earlier record on a child form: after a reference is chosen, a pick of earlier records of the child type with the same value, in any case the person may read, fills listed fields | Built | copy-earlier: [fields] on a reference field of the child's form | New records only; at most 20 offered, by created date or name; only rows whose way up to the case the person may read, only attributes they may view and may change; keyed on one reference; nothing records which record was copied |
| Picker on a child record's form filtered by a field of its parent (line items limited by the case's type) | Built | filtered-by: {field: appeal.program, through: ..., match: ..., option: ...} on the child's form | Proved with the membership form; the reference-list and {field, match} forms read the path by the same code and are parsed and refused alike, but no test runs them; through the record's parents only; on screen, empty for someone who may not view the parent's field (nothing offered); judged on every save from the stored parent, a value left as stored is kept when the parent's field moves; a person who may not view that field cannot choose a value |
Reference picker narrowed by a condition on its records: their state, their fields, their child records (options-where), asked in the database for the list and judged on every save that sets the field | Built on HSQLDB and PostgreSQL | options-where on a reference field of a form, in the queues' where vocabulary | References to entities only, not reference lists; no user leaf and no module leaves; asks nothing of the record being edited; a person who may not view what it reads, or whose rows narrow an entity it reads, is offered nothing and cannot set the field; a value left as stored is not judged again; not run on SQL Server |
| Validation rules on save and on entering a state, errors that refuse and warnings that ask | Built | jcm/rules/<code>.yml | |
| Uniqueness rules | Built | unique: [...] | Checked on save, not by the database; add an index for a hard guarantee |
| Logic beyond rules (derived values, outside checks, named facts) | Built | RecordValidator, RecordLifecycle, RecordFact | RecordFact answers a named fact for a record, a child record included; dynamic field hooks are framework/legacy only, outside the initial API |
| A detected reload loss during a multi-record save refuses the whole save; stored values can be read without loading records | Built | Save behaviour: jcm.save.unsaved-changes=fail is the production default; explicit log/off preserve compatibility while opting out. Use RecordOperations.storedValue/storedValues or ctx.saving(type, id) | Default rollback survives a caught refusal; plain recovery message, no implicit replay. Detector does not cover collection/embedded-only, hook-only post-snapshot or direct entity-manager mutations; unversioned rows may conservatively refuse |
| Questionnaires and wizard (typed, conditional questions, drafts, submit) | Built | jcm/questionnaires/<code>.yml | |
| Collapsible sections, input masks | Planned | Catalogue, no issue | |
| Decision tables or a rules engine (DMN) | Not planned |
3.9 Search
In the contract: Case search. Search refreshes preserve navigation to retained records. Expired clicks and results removed by filtering keep the list open with a sentence asking the user to choose again; a current result still opens normally.
| Capability | Status | How configured | Limits |
|---|---|---|---|
| Quick find in the header (Ctrl+K) by case number and chosen fields | Built | Case-type file search.quick-find: text fields, or dotted paths through single references and embedded values | A path through a collection, a transient reference or another data store stops startup; a record whose reference is empty still matches on its other fields |
| Advanced search with filter chips and a filter language including child conditions, said in plain words | Built | Case-type file search.filters | Only what the user may view |
A condition written as text, the filter language, wherever a condition is written; ends-with; JPQL in queues advised and refused from 0.2.0 | Built | when, where, a child column's where; Conditions.holds from Java | Read as system, as any condition |
| Saved views, personal and shared; shipped read-only views | Built | saved-views | |
| Saved and shared queue filters (Jmix generic filter) | Built | ||
| Search results to CSV | Built | ||
| Full-text search across records and documents | Planned | Catalogue, no issue |
3.10 Reporting, dashboards and analytics
In the contract: Reports, Dashboards and alerts.
| Capability | Status | How configured | Limits |
|---|---|---|---|
| Reports written at runtime with Jmix Reports (templates such as DOCX, XLSX, PDF per Jmix Reports) | Built | Jmix Reports screens; @ReportDef in code | Time and row limits per run (reports in jcm.yml); a database timeout stops JPQL and SQL data sets; Groovy code and formatting are not stopped and fail the run when they return |
Word reports as files: one report per jcm/reports/<code>.yml with its master used byte for byte, the bands and queries, the roles that may run it, fixed at build and refused if the designer or an import tries to change it | Built | jcm/reports/<code>.yml and jcm/reports/<code>/; ReportFiles.load in tests | Word (docx) output only; one record as input; changed by a build, not at run time |
| Reports limited to what the runner can see, unless an administrator sets all-records for named roles | Built | Report access screen | SQL and Groovy data sets refused under runner access; Groovy off |
| Reports on the case screen; every run recorded | Built | ||
| Forms and pages hold up at desktop and laptop widths: new forms open without required errors, long file names wrap, child outcomes wrap, the sticky tab bar is opaque | Built | Nothing to configure | The sample's child bands already fold extra outcomes into More, so the 1024px overflow seen in an application was not reproduced here; the bands now wrap whatever they hold |
| Outcomes and move messages in people's words: an outcome pressed with unsaved edits saves them and goes on, refusals and history name transitions and fields by their labels | Built | Transition name, field captions | Queue buttons and declared actions still ask for a save first; the self-move's own refusals (wrong state, missing role) still name the transition code |
| Dashboards with three tile kinds (queue count, task count, deadline count) per role | Built | jcm/dashboards/<code>.yml | Work layout adds queues and clock lists; chart tiles below |
| Broadcasts by date and role | Built | Admin screen | |
| Chart tiles (by state, age band, assignee), each bar opening its slice of the queue; ageing view by state and band; report time and row limits | Built | chart: tiles in dashboard files; dashboards.ageing-bands, dashboards.max-pass-rows and reports in jcm.yml | Horizontal bars with a table, no other chart types; a count query per bar by state or age, one paged pass over the rows by assignee, for Workload and for users with in-memory rules, refused past max-pass-rows (100,000 by default, at most 1,000,000); at most 8 bands and 50 named assignees; from is an attribute of the row itself |
| Ad hoc BI, pivot tables, embedded analytics | Not planned | ||
| Data export for external BI | Partial | Queue and search CSV; direct database access | No API |
3.11 Configuration, low-code and the studio
In the contract: Configuration studio, Administration console, Assertions.
| Capability | Status | How configured | Limits |
|---|---|---|---|
| Behaviour defined in configuration files under source control | Built | jcm/ folders, jcm.yml | A file edited outside the studio needs a restart; developer-style editing (YAML) |
| Startup checks naming file and line for every error | Built | Some checks run just after the web port opens; startup still stops | |
| Override roots for environment or test variants | Built | jcm.config.overrides | |
| Links below the sign-in form (privacy notice, terms): up to 6 informational links on the login view and the break-glass form | Built | login: {links: [{label, url}]} in jcm.yml | https:// or site-relative / addresses only; labels not translated; the identity provider's own page shows none |
| Runtime-editable items: reference data, queue column layouts, letter templates, deadline durations, broadcasts, reports | Built | Admin screens | Workflows, queues and rules are files, changed through the studio where editing is on |
| Configuration studio views: workflow diagrams with a record's path, queue gallery with previews under the viewer's rights, role matrix with reasons and what each identity file grants at sign-in, where-used, every file line by line | Built | Studio roles | |
| Per-area editing switches, off by default, meant for lower environments | Built | jcm.studio.edit.<area>, jcm.studio.files in that environment's own settings | No default, role or shared profile turns one on; the console warns while one is on |
| Edit, publish, undo and reload configuration in the app | Built | The switches above; studio editor role; the dev profile on a developer's machine | Forms for workflows, queues, inbox tabs, job roles and the role matrix; rules, tasks, deadlines, dashboards, letters, reference lists and the rest are edited as YAML text with line-numbered refusals (their forms are planned); case types, data roles, access.yml and the entity model are staged for the next start (row below); a publish applies to the server that made it, others read it at their next start, so editing is refused while jcm.servers is above 1 (propagation is planned); production is read-only by default and receives changes as committed files (Download, then commit; the app never commits) |
Staged editing of case types, data roles, access.yml and the entity model | Built | jcm.studio.edit.case-types, .roles, .access, .model (the dev profile sets them), jcm.studio.model-files | Checked by the startup readers, written to the source and kept in History, applied at run time by nothing: a restart, a rebuild or ./gradlew jcmChangelog as each needs; a restart can still refuse what no check sees |
| Every change checked as startup checks it, before anything takes effect | Built | One set of checks for startup and publish, proven by refusal fixtures | |
| History of configuration changes with diffs and undo | Built | Undo of the newest publish only, refused where records would be stranded or the file changed since; an undo cannot itself be undone; changes made outside the studio are recorded but cannot be undone there | |
| Administration console: health checks, installed components and versions, record hooks, data dictionary | Built | ||
Developer command with only Docker installed: jcm new from a template (blank, hearings, permits), jcm run (the application with PostgreSQL and a mail catcher in containers, ready when its readiness check answers), jcm check (startup checks, tests, extension-API and Jmix layer checks, one line per stage), jcm changelog (the next changelog and schema.json from the model files) | Built | The jcm launcher (sh; PowerShell with a cmd shim) and the tools image jcm-tools:<version> | The tools image and launcher are not yet published (built from a checkout with cli/build-image.sh, which needs Git and bash); on GitHub's macOS and Windows runners jcm run and the image cannot run (no Docker, or Windows containers only), so there the implementation runs natively; docs/cli/README.md names each gap |
| Publish and promote from the developer's command to hosted environments (dev, test, prod; approval for prod; device-code sign-in with the token in the OS keychain or a 0600 file) | Client built; hosted side Roadmap | jcm login, jcm link, jcm publish, jcm promote, jcm status | Proven against the contract (cli/control-plane-api.yaml) and a fake control plane only; no hosted control plane exists yet |
3.12 Security, roles, permissions and job roles
In the contract: Org-scoped security, Job roles, Sign-in, System work.
| Capability | Status | How configured | Limits |
|---|---|---|---|
| Role-based access (entity, attribute, screen and menu permissions) | Built (Jmix) | Entity and attribute rights in role files (jcm/roles/<code>.yml, fixed when the app is built); compose shipped screen/menu roles; Jmix runtime role screens retain their existing capabilities. Custom Java resource roles are framework/legacy only | JCM components ship their own roles; a role file names each entity it grants and cannot include system-full-access |
| Rights and restricted document types: export formats, filtered export, print, change log, report date range, document types by role | Built | jcm/access.yml, fixed at build, lists what is restricted; a role file grants it with rights, documents and reports | Open by default. default-deny lists the entities read only through a role file's rows; system-rendered-templates is checked but nothing renders as system yet. While anything is restricted a publish cannot reach such a role by a sign-in grant, by a seed user's job, or by moving what keeps it from a person among the jobs or the grants, and a database role cannot include one |
Row rules in role files (rows under an entity): by assignment, by organisation unit, by an attribute of the person, by any condition; children carry the parent's rule; follows for a shared record; each role scoping its own read, update and delete; default-deny | Partial | jcm/roles/<code>.yml, jcm/access.yml; fixed at build, the same text on every server | A stored reference to a hidden row still shows through a fetch plan (the in-memory half is not built); no group assignment; not mixed with generated org-scope roles on one case type; Access scopes on a managed entity only narrow, not yet refused; ALL_RECORDS reports and direct reads of companion entities not yet covered; plans at 50,000 rows and above not measured. Startup asks of each job role that creates a managed case type whether its rules read the record as created, refusing only one certainly false on a default-deny entity; a save out of the saver's reach is stored and RecordOperations.save throws RecordSavedOutOfReach |
| Org-scoped row-level security (user, org unit, parent-child levels) over the case and its composition children | Partial | Org units and memberships, generated row-level roles | Non-composition references not filtered; no default-deny (a user with no scope role sees everything); list performance at scale untested. Row rules in role files cover assignment, shared references and default-deny |
| Scope assigned on create in the same transaction | Built | ||
| Job roles: one job at a time with only its permissions, switched from the header, every switch recorded, timeline names the job | Built | jcm/job-roles/<code>.yml | Narrowing applies only to the Vaadin UI. Users whose roles come from sign-in get their assignments at the first sign-in (marked by jcm_SignInRoleGrant rows), so defaults can be set for them from then on; before, setDefault says they have not signed in yet |
| Transition-level, button-level and queue-level role checks | Built | Workflow and queue files | |
| System work recorded with who asked and why | Built | ||
| Application fields on the user account, one create form | Built | A model entity with extends: user, its form in jcm/extension-forms/, read through AccountProfile and by a user condition | |
| Single sign-on: OIDC | Built | jcm-identity-oidc-starter with jcm.identity.oidc.issuer, client-id, client-secret (JCM_OIDC_*); jcm/identity/<code>.yml mapping claim values to job roles and resource roles, checked at startup and on publish | Tested against Keycloak 26 (the sample's OidcSignInE2eTest: sign-in, the switcher, roles replaced at the next sign-in, an administrator's assignment taking effect in the session, the refusal page, logout ending the provider's session, an administrator's default, realm users named admin, Admin and a database account's name refused with no roles, the first sign-in's linked row reused). Under prod an issuer without a client secret refuses to start unless jcm.identity.oidc.public-client=true. Entra ID and Okta are documented as configuration (docs/deploy/identity.md), not tested live. State, nonce and PKCE on every request. SAML is not supported |
| Single sign-on: LDAP | Built | jcm-identity-ldap-starter with jcm.identity.ldap.url, base-dn, manager-dn, manager-password (JCM_LDAP_*), user and group search settings; jcm/identity/<code>.yml with provider: ldap mapping group names to job roles and resource roles | Tested against OpenLDAP 2.6 (the sample's LdapSignInE2eTest: sign-in on the login form, the switcher, roles replaced at the next sign-in, the refusal on the form, a wrong password, admin refused on the form and signing in at /login/local, an administrator's default, directory users named admin, Admin and a database account's name refused with no roles, the first sign-in's linked row reused, five wrong passwords locking the form for the username). Groups read by a group search (member or uniqueMember), not memberOf. ldaps:// or StartTLS (Active Directory: ldaps:// only); plain ldap:// warns (as.identity.ldap-transport); one spelling per user (another letter case refused). Active Directory is configuration (jcm.identity.ldap.active-directory-domain), documented in docs/deploy/identity.md, not tested live |
| SAML | Not built | Not supported in this release. Jmix's SAML add-on requires a reviewed framework adapter; jcmDirectJmix grants no supported API/dependency exception. A jcm-identity-saml-starter with the same mapping files is planned | |
| Multi-factor authentication | Not built by JCM | Through the identity provider, documented; JCM implements none | An application in production signs in through the provider (OIDC; under LDAP there is no second factor), which enforces MFA and session limits. The database accounts that remain are break-glass accounts, shut unless jcm.identity.local-accounts=true |
| Password policy | Not built by JCM | Through the identity provider, documented; JCM implements none. Break-glass accounts: JCM_ADMIN_PASSWORD sets the admin password in production (startup refuses the scaffold's), jcm.identity.local-accounts off by default | The console watches both (as.identity.admin-password, as.identity.local-accounts); the scaffold ships admin/admin for local use only |
| Account lockout | Built | Every sign-in form (the application's, under LDAP too, and /login/local), always on: jcm.identity.lockout.attempts (5) wrong passwords within window (15m) lock the username for duration (15m) | Keyed on the username alone, never an address or X-Forwarded-For; counted in the database, so every server counts the same. Cost: a known username can be kept locked out. Proven by SignInLockoutFormTest (lock, unlock, a new X-Forwarded-For on every try changes nothing), OidcSignInE2eTest (/login/local) and LdapSignInE2eTest (the LDAP form). Sign-in through OIDC uses the provider's lockout |
| Record edit locks | Planned | Locking exists only inside Get next | |
| Masking of sensitive fields | Planned | ||
| Encryption at rest and in transit | Not built by JCM | Database, storage and TLS settings of the hosting | Hosting responsibility |
3.13 Audit, history and compliance
In the contract: Notes and timeline, Field history.
| Capability | Status | How configured | Limits |
|---|---|---|---|
| Merged timeline per record (opened, moves, assignments, notes, field changes, tasks, deadlines, letters, emails, documents, links, hearings, job-role labels) | Built | Built-in sources; filter chips per kind | Custom TimelineSource is framework/legacy only; no exported custom-source SPI. Reads every entry on each redraw |
| Workflow log, assignment history, job-role switch log, attachment moves, report runs, job runs | Built | ||
| Created and modified by and date on records | Built (Jmix) | Generated entity audit fields | Hand-written Jmix audit traits are framework/legacy only |
| Field-level audit (who, when, old and new value) | Built | Every model field by default (audit: false opts a field out); hand-written entities through jcm/audit/<Entity>.yml | Saves through DataManager and the JPA store only: direct SQL and bulk JPQL updates are not captured. Values over 2,000 characters are kept cut with a marker. A field the reader may not view shows as changed without values; a reference's target is named only if the reader can open it. Removed records' history is kept and shown only with jcm.audit.deleted.read, a removed record's name only to a reader who may view what it is made of. UUID-keyed entities only. Each redraw reads every kept entry of the record and its children. The entity log's time has no zone. No purge job yet. Not run on SQL Server |
| Record of who downloaded a file | Planned | ||
| Retention rules, purge or anonymisation | Planned | Files of a deleted record are kept until the host removes them | |
| Legal hold | Planned | ||
| Privacy: masking, subject access export | Planned (masking) | Subject access export not planned | |
| Notes, letters, documents, tasks never deleted (retracted, withdrawn, cancelled) | Built |
3.14 Integration and APIs
In the contract: Scheduled jobs.
| Capability | Status | How configured | Limits |
|---|---|---|---|
| REST API with the UI's role and job-role checks | Planned | No REST entry points today | |
| Outbound webhooks, signed, with retry | Planned | ||
| JSON for integrations: parse a reply, bind it to a record class, write a request body | Built | The call-only Json facade and JsonValue | A missing field is a missing value, never null; a value of another kind is refused, never converted; 16 MiB and 500 levels at most; entities refused; HTTP through java.net.http |
In-process event on every workflow move (WorkflowTransitionedEvent) | Built internally | Framework/legacy listener only | Use a configured WorkflowEffect for a named move; no exported general event listener |
| OpenAPI documentation | Planned | Depends on the REST API | |
| SFTP, payments, identity provider adapters | Planned | Catalogue only; SFTP import is planned | |
| Outlook or Microsoft 365 integration | Not planned |
3.15 Data import and migration
In the contract: Bulk import, Import files.
| Capability | Status | How configured | Limits |
|---|---|---|---|
| CSV import of new records, checked before saving, all or nothing, as the user (permissions, scope and rules apply) | Built | Entity attributes; @RefListCode on reference fields (code) | Create only; max 5000 rows; no child rows; no references other than reference data; each imported record starts its workflow, as any new record does (WorkflowStarting runs on every create) |
Upsert of shared records by a model unique: key from a delimited file of any size, with every rejected line kept, a reject limit, a resumable run on any server and the Imports screen | Built | jcm/imports/<code>.yml; unique: in the model file; jcm-import-admin | Shared records only (no case types or children yet); no references by key, no after:, no retiring of records missing from a full file; no pickup from a folder (8.3) and no email of the run report yet; tested on HSQLDB, a volume test for PostgreSQL and SQL Server on the gate |
| Child rows, case types, references by key, scheduled import from a folder or SFTP | Planned | Slices A2, C and D of the import-feed design | |
| Bulk migration from a legacy system | Partial | Project migration code with SystemWork.quietly (hooks skipped, logged) and Liquibase | No migration toolkit |
| Seed data for demo and test environments | Built | jcm/seed/<code>.yml | Off unless jcm.seed.enabled |
3.16 External users and portal
| Capability | Status | How configured | Limits |
|---|---|---|---|
| Public portal: external sign-in, file a case, upload documents, track status | Planned | Waiting on an identity provider decision | |
| External users of any kind | Not built |
3.17 Notifications
In the contract: Notification rules.
| Capability | Status | How configured | Limits |
|---|---|---|---|
| In-app and email notifications for assignment, task, deadline, deadline escalation and broadcast, with user preferences | Built | Optional notifications starter and per-source rules; sample and demo ship with them on | Owned inbox, personal choices and provider queue acceptance; no SMTP or exactly-once guarantee |
| Notices that name their record, task or broadcast and open it | Built | Names shown only while the viewer can read the record; email stays generic | |
| Delivery at scale | Built | Default budget per run of the every-minute job | Load test on PostgreSQL: 1,000 deadlines due today delivered in the app in 2 runs (target 10; 39 s of work) and a broadcast to 5,000 users in 9 runs (target 15; 110 s of work; at most 1,000 deliveries a run), PostgreSQL in a container on a developer machine, 2026-10-31 |
| Operator retry of stopped notices | Built | Notification attention screen, jcm-notifications-admin | At most 100 rows shown |
| Dashboard alerts for due-soon and overdue deadlines | Built | Job calling DeadlineNotifications.raise(); with notifications installed, the deadline-due rule instead | Standalone dashboards only (guarded when notifications is installed); the card shows the newest 50 and "50+" |
| Broadcast messages by role and date | Built |
3.18 Accessibility
| Capability | Status | How configured | Limits |
|---|---|---|---|
| Automated axe-core scans for WCAG 2.0 and 2.1 levels A and AA in browser tests | Built | 29 test files call AccessibilityScan; two stock Jmix filter and paging findings are accepted by name; studio scans accept none | |
| Keyboard operation tested | Partial | Keyboard routes for the board (Move to), job-role switcher, quick find and studio walks in 5 browser test files; no full keyboard audit | |
| Live-region announcements (split view next row, dashboard changes) | Built | ||
| Theming tokens with contrast-adjusted badge text | Built | --jcm-* CSS tokens | |
| Manual audit with assistive technology, VPAT or ACR | Not built | None recorded |
3.19 Localisation
| Capability | Status | How configured | Limits |
|---|---|---|---|
| UI text in message bundles, the captions of JCM's own entities among them | Built | messages.properties; a platform caption is overridden in the application's bundle under <class package>/<SimpleName>.<attribute> (com.jcm.tasks/Task.title) | Base (English) bundles only; sample sets available-locales=en |
| Dates in one format on every surface, by the user's locale or set once per application, the time half of a date-time field on the format's clock | Built | jcm.yml dates | Calendar times in server zone; month names in a date field are English |
| Second language across UI, rules and letters, user language switch | Planned | Rule reasons and duplicate texts English only; letters in each addressee's language are built (3.7) | |
| Right-to-left languages | Not planned |
3.20 Usability and mobile
In the contract: Look and theming, Home configuration and selection.
| Capability | Status | How configured | Limits |
|---|---|---|---|
| Responsive layout folding to one column below 960px; side panel full width on a 390px phone (asserted) | Built | Phone layout asserted for the side panel only | |
| The case band laid out by its own width: the record's identity first, the Add menu and the primary move always shown, the other actions while they fit and the rest in one More menu, a held move's reason always in sight | Built | At most three secondary buttons beside the move; checked from 360px to 1920px | |
| Dark colour scheme | Partial | Captured in the screenshot tour, not asserted by a test | |
| Landing page per job role | Built | home: in the job-role file (a work dashboard, a queue or the studio), set in the studio's Job roles editor; secured automatic fallback | The demo manager's home draws three chart tiles |
| Native mobile app, offline use | Not planned |
3.21 Performance, scalability and availability
| Capability | Status | How configured | Limits |
|---|---|---|---|
| Stated response times, load test, query-count tests | Planned | Several per-row query issues deferred (letters, timeline, case controls, alerts) | |
| Expected scale | Stated | Design target "departmental, not national" until a project says otherwise | |
| Clustered scheduled jobs | Built | One run across two servers proven (ClusterJobsE2eTest); rolling-deployment caveat (docs/deploy/README.md, Upgrades) | |
| High availability, multi-node web tier | Built | Load balancer with cookie affinity in front of servers sharing the database and file store (sample-appeals/deploy/cluster/compose.yml, docs/deploy/README.md, Several servers); readiness at /actuator/health/readiness takes a server out | Sessions not replicated: a server that stops signs its users out, the others carry on (tested); studio editing refused above one server, propagation planned; two servers tested, on one machine; no database or store failover of JCM's own (the hosting's) |
| Caching | Not built |
3.22 Hosting, environments, DevOps and testing approach
In the contract: Tenant plan and usage.
| Capability | Status | How configured | Limits |
|---|---|---|---|
| Environment-specific settings (Spring profiles, environment variables, override roots) | Built | The prod profile, application-prod.properties: every setting from a JCM_* environment variable (table in docs/deploy/README.md) | Startup stops naming a required variable that is not set; secrets are never written in a file; no login defaults and no studio editing in production |
| Configuration and schema changes in source control (YAML files, Liquibase changelogs) | Built | ||
Health checks at startup and on demand; liveness and readiness endpoints for an orchestrator (/actuator/health/liveness, /actuator/health/readiness: readiness waits for startup, the database and the blocking assertions; anonymous, the status word only, no other actuator endpoint exposed) | Built | ||
| Scheduled jobs with run history, failures, run now | Built | jcm/jobs/<code>.yml plus JcmJob bean | |
| Durable work for components: leased rows with retries, a list runner with a snapshot, a cursor and a transaction per entry, work that stops for a person on "Work needing attention" | Built | LeasedWork, LeasedList, AttentionSource | For components, not yet an extension point |
File automations: a record moves or acts after an event, such as a document arriving, with no person: jcm/automations/<code>.yml, after commit, retried, stopped work on "Work needing attention" and in the run history, a depth limit, read in the studio, shown on the timeline | Built | jcm/automations/<code>.yml | Sends letters and email with no person at work: letter, email and send write only templates whose readers jcm/access.yml pins (system-rendered-templates), refused at the line, on publish and when run for any other, and go to none of the application's people who may not read them; notify and post are not built yet |
Java listeners on events, at least once, with replay: RecordEventListener | Built | RecordEventListener bean | |
| Domain events: what happened to a record, written in the transaction that caused it, numbered per record in commit order, fanned out and delivered in order, purged when finished | Built | jcm-events-starter; jcm.events.keep-days (90) | No subscribers until file automations and listeners; no order across records; quiet saves and bulk updates make no event |
| Three test layers per change: service tests on a real database, UI integration tests, browser tests in headless Chrome against the production frontend bundle | Built | ./gradlew clean test e2eTest | |
| Concurrency tests (Get next, bookings) in both HSQLDB transaction modes | Built | ||
Container image and CI pipeline: a Dockerfile per application (non-root, prod profile, readiness health check, no secret in the image; the scaffold writes one), the demo compose stack with PostgreSQL, Keycloak and MinIO, GitHub Actions running the suites on HSQLDB and PostgreSQL, the image check and the scaffold check on every push, and a release gate for SQL Server and two servers | Built | docker build -f <app>/Dockerfile .; deploy/demo/.env from .env.example | The image and the stack are built and checked by scripts/test-image.sh, the scaffold's by scripts/test-new-app.sh. The demo stack's Keycloak runs in development mode and its MinIO image is frozen: a demo, not a deployment. The release gate (release-gate.yml: SQL Server, PostgreSQL, the cluster run) passed all three jobs in CI |
| Tenant usage and health reporting: counts, versions and health words only, hourly by default, one server per cycle, shown to the customer exactly as sent; off with no tenant id, so a self-hosted application contacts nobody | Client built; hosted side Roadmap | tenant in jcm.yml or JCM_TENANT_*, jcm-tenant-starter | Proven against the contract (cli/tenant-plane-api.yaml) and a fake control plane only. Letter files are counted but have no recorded size; active users are enabled accounts, not recent sign-ins |
| Plan enforcement: a signed plan (Ed25519) refuses components it does not include at startup, a control plane outage never stops a tenant with a cached plan, expiry never stops a running application and allows restarts for 30 days | Client built; hosted side Roadmap | A mounted document (named only in the environment) or the control plane; never one issued before the plan held or dated more than five minutes ahead of the clock; a held plan dated ahead goes only for a signed document naming it (replaces_issued_at) | Runs inside the application and trusts its clock, so it is no defence against a tenant who controls the build. No production signing key is built in yet |
| Production installer, log viewer | Planned | No issue | |
| Hosting certifications (FedRAMP, StateRAMP, ISO 27001, SOC 2) | Not applicable to the framework | Belongs to the hosting platform |
3.23 Extensibility
| Capability | Status | How configured | Limits |
|---|---|---|---|
| Record lifecycle hooks (before create, update, delete; after commit) and record validators | Built | Java beans | |
| Create records and query by relationship from extensions | Built | RecordOperations.create and query from a hook (ctx.save), an effect or a job; children by their parent link (e.request = :parent) | Conditions and order through to-one references only, with the related entity's read row rules applied; every save checks each changed field's modify permission and that a changed reference points at a readable record; no delete |
| System work for actions beyond the user's rights, recorded | Built | SystemWork | |
| Case screen overrides: settings or one replaced section | Built | Case-type settings or CaseScreenSection bean | Own Jmix views and internal controls are framework/legacy only |
| Screen sections built from ordinary controls (grid, check box, date picker, combo box, dialog) with safe links | Built | The approved controls, member by member; links only from ScreenLinks (http, https, mailto, a saved case or an application route) | No raw HTML, element properties, script or free attributes through the approved controls, and no reflection; a checked surface, not a sandbox for hostile code |
Plugin upgrades keep applications building: older shell templates accepted with a warning, jcmUpgradeShell moves unmodified shell files to the current set | Built | ./gradlew jcmUpgradeShell | An edited shell file stops the whole upgrade, which then writes the current templates under build/jcm/shell to compare with |
| Case controls in framework/legacy Jmix view XML, with a published schema | Built internally | Generated screen configuration is supported | Custom XML controllers/controls are outside the manifest |
Move a record from a job, hook or effect, every check of the transition holding; ask which moves are open; start a new record in a state the workflow marks entry: true | Built | RecordMoves.move, available, saveStartingIn; entry: true on a state; state: on a create action (configuration) | Refusals are WorkflowException; the start runs the marked state's actions and none of the initial state's |
| Start the workflow on records stored before their type had one (adoption), audited and safe to repeat; in bulk by a job with a pilot limit and a counted summary | Built | adopt: {roles, states} in the workflow file (configuration); RecordMoves.adopt; JobContext.summary | Every start effect of the entered state runs, clocks from the adoption day, and none of the earlier states'; no quiet mode; bulk is a job the application writes at batch: 1; no button yet. See Adopting stored records |
| Scheduled jobs, workflow effects and queue group resolver | Built | JcmJob, WorkflowEffect, QueueGroupResolver beans, for what workflow file actions and assignment rules (configuration) cannot say | Timeline sources, health checks, business-calendar and record-panel replacement are framework/legacy only |
| Any additional Jmix add-on (BPM, maps, charts, multitenancy) | Available from Jmix | Requires reviewed framework integration and policy changes | jcmDirectJmix and source comments do not override checkJcmApi |
5. Known gaps and roadmap
| Gap |
|---|
| Escalation and timer transitions on deadlines |
| Combo chart tile |
| Ad hoc email from a case: built with limits (no outside address, plain text) |
| Gap |
|---|
| Public portal with external sign-in |
| REST API and outbound webhooks |
| Inbound email with threading |
| Document versions, preview, download log |
| Retention, purge, legal hold |
| N+1 protection and a performance baseline (100,000 cases) |
| Record edit locks and sensitive-field masking |
| Import: update by key, child rows, column mapping, schedule |
| A second language |
| Parties and contacts; case merge |
| Correspondence: batch letters (the picker and blocks are built) |
| E-signature and SMS adapters |
| Move stored files between file stores |
| SAML sign-in through a JCM starter |
| Studio editing on several servers: a publish propagated to every running server |
Planned in the catalogue with no issue: BPM adapter, collapsible form sections, input masks, full-text search, SFTP, payments, identity integrations other than OIDC, LDAP and SAML, log viewer, production installer, later studio work (case types reloaded, forms for the remaining kinds, a condition builder, a Git publish target; propagation across servers is planned). Not planned: parallel branches in one workflow, DMN, native mobile, right-to-left languages, BI tooling, DMS integration.
Known defects include: deadline badge counts business days for calendar-day policies; calendar shows server-local times with no zone and does not detect daylight-saving gaps; report runs have no limits; several per-row query patterns.