Skip to content

Topics ​

Each issue takes a single core topic and weaves Erupt's capabilities — scattered across source code, annotations, and modules — into a readable, hands-on, competitor-comparable narrative.

Cadence: roughly one issue per month.

Erupt WeChat Official Account
WeChat · Official Account
Scan to follow the Erupt official account

Each issue debuts here, along with release notes, source-code deep dives, and community case studies. Reply "加群" to join the user group, or "入门" for a 5-minute getting-started guide.

📚 Scroll down for published topics → Archive

Archive

#27
Modules

Switching a Module Off Is Not an Uninstall

With 46 modules installed, a newcomer faces a wall of menus. The module center in erupt-upms is not a plugin market: switching a module off is one column, e_upms_module.enabled, and the work is done by EruptMenuSeeder. It skips unchanged modules by fingerprint, otherwise merges every menu field three ways (database, last written, now declared) and keeps administrator edits; switching off takes the same path and disables menus instead of hiding them, since a hidden menu still grants access. The cost is stated: only the entrance closes, beans, endpoints and jobs keep running.

2026-11-04·9 min read
#26
Share

A Public Link Should Not Be a Second Auth System

The easy way to let a stranger submit data is an anonymous endpoint. erupt-share does the opposite: opening a link mints an ordinary session in the issuer's name, then SessionScopeGuard narrows it to one form through a 22-route whitelist. A link never exceeds its issuer, disabling it ends issued sessions, failures are rate limited per IP, and visits are counted in one UPDATE. The cost is stated: the visitor session still writes data in the issuer's name.

2026-11-02·9 min read
#25
AI Dev

A Badge for the Coding Agent

Getting AI to write code is easy; authorization and delivery are hard. erupt-ai-dev builds no permission system for the agent: each run gets a DevMcpGrants token pointing at one requirement, accepted by erupt-ai's /mcp through McpAuthenticator, with data access borrowed from the creator's AI roles. Review, acceptance and delivery are plain @RowOperation, self-review off by default; multi-repo delivery rebases everything first and pushes nothing on any conflict. The costs are stated: the agent runs as the server account, and what it reads goes to the model provider.

2026-10-28·10 min read
#24
Config

A Config Center Doesn't Have to Be Another Service

The admin's "system settings" is usually a key/value table plus a getConfig helper: callers run their own cache, and it knows nothing of application.yml. erupt-config adds no read API; the items become the front-most PropertySource of the Spring environment, loaded over JDBC by EruptConfigEnvironmentPostProcessor before any bean exists and read unchanged by @Value and @ConfigurationProperties. A save swaps the whole layer, sets @Value fields again and publishes EruptConfigRefreshedEvent; other nodes follow by Redis broadcast or by polling an aggregate signature. Costs are stated up front: no versions, canary or approval, secrets masked but not encrypted, SpEL and constructor injection resolved only at startup.

2026-10-21·9 min read
#23
SSO

The Hard Part of SAML Is Refusing

The usual reflex for enterprise SAML is "find a mature library" — but a library only solves the mathematics of XML signatures; whether a response may log in depends on what you check around verification and in what order. SsoSamlService in erupt-sso is 406 lines on the JDK's javax.xml.crypto.dsig alone: one-use state, InResponseTo, Destination, audience and validity window, a signature that references only itself, an ID resolvable only on the signed element to stop signature wrapping, and encrypted assertions refused outright. Costs are stated up front: no assertion decryption, no signed AuthnRequest, no single logout, and Erupt cannot be the IdP.

2026-10-20·10 min read
#22
Webhook

Don't Notify Anyone Before the Transaction Commits

The easiest way to push a data change elsewhere is an HTTP call in DataProxy#afterAdd — which runs before commit and parks the request thread on the receiver. erupt-webhook goes the other way: it subscribes to the EruptAddEvent / EruptEditEvent / EruptDeleteEvent the pipeline already publishes, matches subscriptions only AFTER_COMMIT, and a background worker signs with HMAC-SHA256, tries 3 times and logs each delivery; rolled-back writes notify no one. The subscription and log tables are ordinary @Erupt models. Costs stated up front: no durable queue, the subscription cache refreshes on the local node only, masking covers PASSWORD fields only.

2026-10-19·9 min read
#21
Scope

"The Current Project" Should Not Be a where Clause

In multi-project, multi-cluster admins, "current scope" is usually a front-end dropdown plus hand-written filters on every table. @EruptScope declares the scope as an ordinary @Erupt form class: the client sends one value, EruptScopeService re-validates it against the current user's options on every request and rewrites list queries, by-id checks and adds / edits, and a required scope is never guessed. Limits stated up front: a scope is not a permission; keeping users apart still takes per-user options or data permissions.

2026-10-19·9 min read
#20
Cloud

A Node Is Not a Spring App, It Is a Protocol

In a traditional distributed admin, every service you add means wiring the gateway, tokens and permissions once more. erupt-cloud bets the other way: the server handles login, menus, validation, Excel and attachments, and a node hands over only a model description and data access; forwards are HMAC-signed by CloudSignature, and Erupt-Enforced says which checks the server already ran. Thin enough that erupt-cloud-node-lite is about 2,400 lines with no Spring. Costs stated up front: the protocol is still Draft v0, the lite node lacks sub-tables, trees and file upload, and the cross-language conformance suite lives in a separate repo.

2026-10-16·10 min read
#19
Validation

Declare Once, Enforce Everywhere

Field rules in most low-code platforms are UI settings in a designer: the browser stops you, a direct call to the write endpoint may not. Erupt's @Edit is one annotation read by both the page and the server, and EruptValueValidator runs the declared options, lengths, number ranges and date bounds again inside the write pipeline: 8 component types, 5 write entry points, sub-table rows and Excel import included. The costs are written down too: time-type pickers aren't bound-checked, and choice-validate on by default refuses old out-of-range writes.

2026-10-15·10 min read
#18
History

Change History Belongs to No DataProxy

Field history in business code usually means one xxx_history per model. erupt-revision bets the other way: no DataProxy, just the EruptEditEvent the pipeline already publishes, with a field-level diff written in the caller's transaction. Rollback re-enters updateEruptData so validation and hooks still run, and the rollback is itself recorded. Gaps stated up front: drag sorting publishes no event, writes that bypass the pipeline are invisible, and a failed history write only logs a warning.

2026-10-08·9 min read
#17
Views

One Table, Eight Views

Mingdaoyun, Jiandaoyun and Yida make views objects of the platform, each with its own filter and grouping. @Vis bets the other way: a view is a projection of one TableQuery, row-level permission in DataProxy#beforeFetch applies to all 8 view types at once, and column statistics share assembleQuery with the list. The gap is written down too: board, calendar and Gantt drags skip whole-row validation and verifyIdPermissions.

2026-10-03·10 min read
#16
Data Source

When the Data Isn't in Your Database

When data lives in DingTalk Notable, Feishu Bitable, Airtable or someone else's REST API, Yida, Mingdaoyun and Jiandaoyun answer with "connector + sync". Erupt bets the other way: don't move the data, swap the engine — one @EruptDataProcessor line, and validation, DataProxy, permissions and logging stay on one pipeline; any REST API's quirks fold into 8 EruptHttpAdapter hooks. The costs are written down too: a 5,000-row cap, equality-only push-down by default, beforeFetch understood only as equality fragments, and no transactions across HTTP.

2026-10-02·11 min read
#15
Decision

Putting AI Judgements Back Inside an if Statement

Workflow LLM nodes emit a paragraph, and a downstream branch tries to guess what it meant. erupt-ai-decision answers only three typed questions — NOUL yes/no, CHOICE pick-one, SCORE ordered levels — each with a probability distribution, and "not sure" is an Optional.empty() branch. Set against Yida, Jiandaoyun, JeecgBoot and Dify: the model says how much it looks like, the code says whether it counts, and the threshold always lives in your if.

2026-10-01·10 min read
#14
Generator

Generating Models from an Existing Database

In Issue 05 we said Erupt has no verb called "generate." Now erupt-generator can read an existing database backwards, turning a column comment like "0-unpaid 1-paid" into a @ChoiceType and a foreign-key constraint into a reference annotated on the real column. The two don't conflict: RuoYi and JeecgBoot turn one table into a full stack of layers; Erupt turns one table into exactly one @Erupt class, never writes into your source tree, and leaves no runtime trace. Generate once, then step aside.

2026-09-23·10 min read
#13
Identity

A Login Chain Without Spring Security

The usual way to add SSO is to pull in spring-security-oauth2-client, write a SecurityFilterChain, and pick a JWT library. Erupt pulled in none of them. Not out of a taste for reinventing wheels, but because once the login chain is split across Filters and external starters, "can this account get in?" stops being a single judgment. This issue walks the seven-step login chain Erupt runs on its own: the SSO provider is an @Erupt table rather than YAML, id_token is never read, tokens never enter the URL, and the lockout key is account+IP, not account.

2026-09-21·11 min read
#12
Remote Access

Security Boundaries for Remote Hosts

Opening an SSH terminal in the browser has two mature paths: a bastion like JumpServer, with its own account system and audit trail, or a panel like 1Panel or BT Panel, which is root the moment it is installed and has almost no boundary. Erupt bets on a third: a remote host is an ordinary @Erupt model that goes through the same menu permissions, the same DataProxy, the same row filtering, with no new account table and no resident process. The price is drawing every security line yourself. This issue lays them out one by one, including two things we deliberately do not do.

2026-09-18·11 min read
#11
Record Comment

Why Comments Don't Bind to Business Tables

Everyone who builds back offices has added a remark column to some table, then remark_user and remark_time, then an xxx_comment child table, and then done it all again for the next entity. Yida hangs comments on workflow nodes; Jiandaoyun hangs them on forms. Erupt bets the other way: one table that knows no business entity, addressed by (model name, primary key string). And in a multi-node deployment the record lives on the node while the comment lives at the center, which is what forced the cloudProxy switch on @EruptRouter.

2026-09-17·10 min read
#10
Cell Edit

Why Cell Edits Run the Whole-Row Pipeline

Back-office tables are converging on spreadsheet-style UIs: double-click, edit one field in place. Great experience, but on the server it opens a write path that carries a single field. Cross-field rules never run, DataProxy receives a truncated entity, read-only becomes decorative, and the display values afterFetch filled in get written back. Erupt bets the other way: cell editing does not get a path of its own. It loads the whole row, applies a patch, and runs the full edit pipeline again. All seven gates sit on the server.

2026-09-16·10 min read
#09
Model Atlas

Model Atlas as a Static Audit

Low-code platforms draw model relationship diagrams mostly to look professional. erupt-atlas bets the other way: the diagram is a by-product, and the real output is a static audit of the runtime registry: circular dependencies (Tarjan SCC), shared physical tables, orphan models, models with no menu attached, and permissions declared but never grown into a button. Three REST endpoints return structured JSON that a person can read and CI can assert on.

2026-09-15·10 min read
#08
Annotation DX

What you write in an annotation isn't a string — it's code with syntax

The favorite rebuttal against annotation-based low-code is "annotations just turn SQL into unhighlighted dumb strings." Erupt bets the reverse — it uses JetBrains @Language to inject 10 embedded languages (hql/sql/VTL/markdown/java…) into its own annotation attributes, so a single sql="..." gets highlighting, completion, and error checking in IntelliJ; @Comment then makes the same attribute self-describing for both humans and AI.

2026-07-01·9 min read
#07
Runtime Designer

ByteBuddy × JsonAnnotationProxy × @EruptDataProcessor: We built a designer, but it compiles into a real @Erupt class

Nearly every online form designer stores the design as a JSON DSL and renders it at runtime through an interpreter. erupt-designer bets the opposite way — at runtime the design is compiled by ByteBuddy into a real @Erupt class, reusing the exact same pipeline as a hand-written entity: Gson, reflection, validation, DataProxy, @EruptFlow. No restart, no generated code, no interpreter.

2026-06-17·10 min read
#06
Secure by Default

@Power × SHA512+Salt × PowerHandler: in low-code, "security" shouldn't be the column you fill in right before launch

For most domestic admin frameworks, security is a "configure it before launch" checklist — RBAC, button permissions, password encryption are all to-do items. Erupt bets the reverse: security is the default value of an annotation. @Power defaults export/importable to false, PowerHandler enforces at runtime, and passwords migrate from MD5 to SHA-512+Salt automatically on the next change — no downtime, no rehash script.

2026-06-10·10 min read
#05
Design Philosophy

Annotation × Spring × Git: the most controllable low-code platform — no verb called "generate"

Chinese low-code = drag-and-drop canvases or on-platform Node.js editors, all built for business operators. Erupt bets on the opposite lane — low-code for backend engineers: annotations are the config, extension points are Spring beans, the source of truth lives in Git, and the framework writes zero bytes into your source tree. 17 LLMs + A2A + memory + @AiToolbox ship as default dependencies, not AI add-ons.

2026-06-01·10 min read
#04
Cube × LLM

Let the BI dashboard answer "why did it change" — the new shape of Erupt Cube × LLM

Traditional BI tools give you the "what"; Erupt Cube × LLM gives you the "why". The @EruptCube annotation defines a semantic layer, and the LLM grows three eyes alongside the domain model (cubeList → cubeMetadata → cubeQuery): it writes the SQL, renders the chart, and produces the attribution. This issue stitches together the AI Harness from #01 and the "annotation-first" narrative from #03.

2026-05-28·11 min read
#03
AI × Flow × Cloud

While MyBatis-Plus still battles SQL DSLs, Erupt wraps a whole admin infrastructure around JPA

In Erupt, a single @Entity grows ten identities — UI, RBAC, REST API, auto DDL, i18n, DataProxy, lambda queries, AI Agent, workflow engine, cross-service aggregation. The annotation is the config surface; metadata = UI = API = LLM Tool.

2026-05-25·10 min read
#02
Design Philosophy

@Erupt × DataProxy × Handler: why we did not go with a drag-and-drop canvas

While DingTalk Yida, Jiandao Cloud, and JeecgBoot all bet on "canvas" or "canvas-generates-code", Erupt still bets on the source code itself — a single @Erupt annotation, a DataProxy<T> extension point, and a set of Handler interfaces. This issue explains why.

2026-05-22·9 min read
#01
AI Harness

50+ LLMs × A2A × Memory: how Erupt's AI Harness came to life

17 providers, the A2A cross-agent protocol, cross-session Memory, plus a Tool / MCP call you can wire up with a single Java annotation — why we believe a Java backend shouldn't be locked into the "AI app generator" narrative of products like ToolJet.

2026-05-22·10 min read

Want to submit a topic?

A topic is not a changelog or a module manual — it tells the story of how a single idea takes shape inside Erupt. If your Erupt journey carved out a unique path, propose it on GitHub Discussions; accepted ideas will be published as a Topic.

Contributors

The avatar of contributor named as YuePeng YuePeng

Changelog

Released under the Apache-2.0 License.